@whitewall/blip-sdk 0.0.178 → 0.0.180

package/src/utils/builder.ts

@@ -0,0 +1,165 @@
+import type { Action, ContentActionItem, State } from '../types/flow.ts'
+
+export type MinifiedAction = {
+    type: string
+    settings: Record<string, unknown>
+    conditions?: Array<{
+        source: string
+        variable?: string
+        comparison: string
+        operator?: string
+        values: Array<string>
+    }>
+}
+
+export type MinifiedInput = {
+    bypass: boolean
+    variable?: string
+    validation?: { rule: string; regex?: string; type?: string; error: string }
+    expiration?: string
+    conditions?: MinifiedAction['conditions']
+}
+
+export type MinifiedOutput = {
+    stateId: string
+    stateName?: string
+    typeOfStateId?: string
+    conditions?: MinifiedAction['conditions']
+}
+
+export type MinifiedState = {
+    id: string
+    name: string
+    root?: boolean
+    enteringActions?: Array<MinifiedAction>
+    contentActions?: Array<{ action?: MinifiedAction; input?: MinifiedInput }>
+    leavingActions?: Array<MinifiedAction>
+    outputs?: Array<MinifiedOutput>
+    defaultOutput: { stateId: string; stateName?: string; typeOfStateId?: string }
+    afterStateChangedActions?: Array<MinifiedAction>
+    localActions?: Array<MinifiedAction>
+}
+
+function minifyConditions(
+    conditions?: Array<{
+        source: string
+        variable?: string
+        comparison: string
+        operator?: string
+        values: Array<string>
+    }>,
+): MinifiedAction['conditions'] | undefined {
+    if (!conditions || conditions.length === 0) return undefined
+    return conditions.map((c) => ({
+        source: c.source,
+        ...(c.variable ? { variable: c.variable } : {}),
+        comparison: c.comparison,
+        ...(c.operator ? { operator: c.operator } : {}),
+        values: c.values,
+    }))
+}
+
+function minifyActionSettings(settings: Record<string, unknown>): Record<string, unknown> {
+    const clone = { ...settings }
+    delete clone.$invalid
+    delete clone.id
+    return clone
+}
+
+export function minifyAction(action: Action): MinifiedAction {
+    const result: MinifiedAction = {
+        type: action.type,
+        settings: minifyActionSettings(action.settings as Record<string, unknown>),
+    }
+    const conditions = minifyConditions(action.conditions as MinifiedAction['conditions'])
+    if (conditions) result.conditions = conditions
+    return result
+}
+
+function minifyInput(input: ContentActionItem['input']): MinifiedInput | undefined {
+    if (!input) return undefined
+    const result: MinifiedInput = { bypass: input.bypass }
+    if (input.variable) result.variable = input.variable
+    if (input.validation) {
+        result.validation = {
+            rule: input.validation.rule,
+            ...(input.validation.regex ? { regex: input.validation.regex } : {}),
+            ...(input.validation.type ? { type: input.validation.type } : {}),
+            error: input.validation.error,
+        }
+    }
+    if (input.expiration) result.expiration = input.expiration
+    const conditions = minifyConditions(input.conditions as MinifiedAction['conditions'])
+    if (conditions) result.conditions = conditions
+    return result
+}
+
+export function isChatStateSendMessage(item: ContentActionItem): boolean {
+    return item.action?.type === 'SendMessage' && item.action.$typeOfContent === 'chat-state'
+}
+
+export function resolveStateName(stateId: string, flow: Record<string, State>): string | undefined {
+    const state = flow[stateId]
+    return state?.$title
+}
+
+function minifyOutput(
+    output: { stateId: string; typeOfStateId?: string; conditions?: Array<unknown>; $invalid?: boolean },
+    flow: Record<string, State>,
+): MinifiedOutput {
+    const result: MinifiedOutput = {
+        stateId: output.stateId,
+    }
+    const name = resolveStateName(output.stateId, flow)
+    if (name) result.stateName = name
+    if (output.typeOfStateId) result.typeOfStateId = output.typeOfStateId
+    if ('conditions' in output && Array.isArray(output.conditions) && output.conditions.length > 0) {
+        result.conditions = minifyConditions(output.conditions as MinifiedAction['conditions'])
+    }
+    return result
+}
+
+export function minifyState(stateId: string, state: State, flow: Record<string, State>): MinifiedState {
+    const result: MinifiedState = {
+        id: stateId,
+        name: state.$title,
+        defaultOutput: {
+            stateId: state.$defaultOutput.stateId,
+            ...(resolveStateName(state.$defaultOutput.stateId, flow)
+                ? { stateName: resolveStateName(state.$defaultOutput.stateId, flow) }
+                : {}),
+            ...(state.$defaultOutput.typeOfStateId ? { typeOfStateId: state.$defaultOutput.typeOfStateId } : {}),
+        },
+    }
+
+    if (state.root) result.root = true
+
+    const enteringActions = state.$enteringCustomActions.map(minifyAction)
+    if (enteringActions.length > 0) result.enteringActions = enteringActions
+
+    const contentActions = state.$contentActions
+        .filter((item: ContentActionItem) => !isChatStateSendMessage(item))
+        .map((item: ContentActionItem) => {
+            const entry: { action?: MinifiedAction; input?: MinifiedInput } = {}
+            if (item.action) entry.action = minifyAction(item.action)
+            const input = minifyInput(item.input)
+            if (input) entry.input = input
+            return entry
+        })
+        .filter((entry: { action?: MinifiedAction; input?: MinifiedInput }) => entry.action || entry.input)
+    if (contentActions.length > 0) result.contentActions = contentActions
+
+    const leavingActions = state.$leavingCustomActions.map(minifyAction)
+    if (leavingActions.length > 0) result.leavingActions = leavingActions
+
+    const outputs = state.$conditionOutputs.map((o: State['$conditionOutputs'][number]) => minifyOutput(o, flow))
+    if (outputs.length > 0) result.outputs = outputs
+
+    const afterStateChangedActions = (state.$afterStateChangedActions ?? []).map(minifyAction)
+    if (afterStateChangedActions.length > 0) result.afterStateChangedActions = afterStateChangedActions
+
+    const localActions = (state.$localCustomActions ?? []).map(minifyAction)
+    if (localActions.length > 0) result.localActions = localActions
+
+    return result
+}