@fugood/bricks-project 2.21.0-beta.14.test0

package/compile/util.ts

@@ -0,0 +1,347 @@
+import { makeId } from '../uuid'
+
+type ScriptConfig = {
+  inputs: Record<string, string>
+  enable_async: boolean
+  disabled_triggers: Record<string, boolean>
+  output: string | null
+  outputs: Record<string, string[]>
+  error: string | null
+  code: string
+}
+
+const errorMsg = 'Not allow duplicate set property id between inputs / outputs / output / error.'
+
+export const validateConfig = (config: ScriptConfig) => {
+  if (config.error && config.inputs[config.error]) {
+    throw new Error(`${errorMsg}. key: error`)
+  }
+  if (config.output && config.inputs[config.output]) {
+    throw new Error(`${errorMsg}. key: output`)
+  }
+  if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
+    throw new Error(`${errorMsg}. key: outputs`)
+  }
+}
+
+const padding = 15
+const layerXInterval = 300
+const layerYInterval = 150
+
+export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMode?: boolean }) => {
+  validateConfig(config)
+  const sandboxId = makeId('property_bank_command', opts)
+  const sandboxErrorId = makeId('property_bank_command', opts)
+  const sandboxResultId = makeId('property_bank_command', opts)
+
+  const inputs = Object.entries(config.inputs).reduce(
+    (acc, [key, value], index) => {
+      const commandId = makeId('property_bank_command', opts)
+      acc.map[key] = {
+        type: 'data-node',
+        properties: {},
+        in: {
+          change: null,
+        },
+        out: {
+          value: [
+            {
+              id: commandId,
+              port: 'value',
+            },
+          ],
+        },
+      }
+      acc.editorInfo[key] = {
+        position: { x: padding, y: index * layerYInterval + padding },
+        points: {},
+      }
+      if (acc.prevCommandId) {
+        acc.map[acc.prevCommandId].out.result = [
+          {
+            id: commandId,
+            port: 'obj',
+          },
+        ]
+      }
+      acc.map[commandId] = {
+        type: 'command-node-object',
+        title: 'Command: OBJECT_SET',
+        properties: {
+          command: 'OBJECT_SET',
+          args: {
+            path: value,
+          },
+        },
+        in: {
+          obj: acc.prevCommandId
+            ? [
+                {
+                  id: acc.prevCommandId,
+                  port: 'result',
+                },
+              ]
+            : null,
+          path: null,
+          value: [
+            {
+              id: key,
+              port: 'value',
+              disable_trigger_command_in: config.disabled_triggers?.[key] ? sandboxId : undefined,
+            },
+          ],
+        },
+        out: {
+          result: [
+            {
+              id: sandboxId,
+              port: 'inputs',
+            },
+          ],
+        },
+      }
+      acc.editorInfo[commandId] = {
+        position: { x: layerXInterval, y: index * layerYInterval + padding },
+        points: {},
+      }
+      acc.prevCommandId = commandId
+      return acc
+    },
+    { map: {}, editorInfo: {}, prevCommandId: null } as {
+      map: Record<string, any>
+      editorInfo: Record<string, any>
+      prevCommandId: string | null
+    },
+  )
+
+  let y = 0
+  const outputs = Object.entries(config.outputs).reduce(
+    (acc, [key, pbList], index) => {
+      const commandId = makeId('property_bank_command', opts)
+      acc.commandIdList.push(commandId)
+      acc.map[commandId] = {
+        type: 'command-node-object',
+        title: 'Command: OBJECT_GET',
+        properties: {
+          command: 'OBJECT_GET',
+          args: {
+            path: key,
+          },
+        },
+        in: {
+          obj: [
+            {
+              id: sandboxResultId,
+              port: 'result',
+            },
+          ],
+          path: null,
+        },
+        out: {
+          result: pbList.map((pb) => ({
+            id: pb,
+            port: 'change',
+          })),
+        },
+      }
+      acc.editorInfo[commandId] = {
+        position: {
+          x: layerXInterval * 3,
+          y: index * layerYInterval + padding,
+        },
+        points: {},
+      }
+      pbList.forEach((pb, pbIndex) => {
+        acc.map[pb] = {
+          type: 'data-node',
+          properties: {},
+          in: {
+            change: [
+              {
+                id: commandId,
+                port: 'result',
+              },
+            ],
+          },
+          out: {
+            value: null,
+          },
+        }
+        acc.editorInfo[pb] = {
+          position: {
+            x: layerXInterval * 4,
+            y: padding + y + index * layerYInterval + pbIndex * layerYInterval,
+          },
+          points: {},
+        }
+        if (pbIndex > 0) y += layerYInterval
+      })
+      return acc
+    },
+    { map: {}, editorInfo: {}, commandIdList: [] } as {
+      map: Record<string, any>
+      editorInfo: Record<string, any>
+      commandIdList: string[]
+    },
+  )
+
+  return {
+    map: {
+      ...inputs.map,
+      [sandboxId]: {
+        type: 'command-node-sandbox',
+        title: 'Command: SANDBOX_RUN_JAVASCRIPT',
+        properties: {
+          command: 'SANDBOX_RUN_JAVASCRIPT',
+          args: {
+            code: config.code,
+            enable_async: config.enable_async,
+          },
+        },
+        in: {
+          code: null,
+          inputs: inputs.prevCommandId
+            ? [
+                {
+                  id: inputs.prevCommandId,
+                  port: 'result',
+                },
+              ]
+            : [],
+        },
+        out: {
+          result: [
+            {
+              id: sandboxErrorId,
+              port: 'result',
+            },
+            {
+              id: sandboxResultId,
+              port: 'result',
+            },
+          ],
+        },
+      },
+      [sandboxErrorId]: {
+        type: 'command-node-sandbox',
+        title: 'Command: SANDBOX_GET_ERROR',
+        properties: {
+          command: 'SANDBOX_GET_ERROR',
+        },
+        in: {
+          result: [
+            {
+              id: sandboxId,
+              port: 'result',
+            },
+          ],
+        },
+        out: {
+          result: config.error
+            ? [
+                {
+                  id: config.error,
+                  port: 'change',
+                },
+              ]
+            : [],
+        },
+      },
+      [sandboxResultId]: {
+        type: 'command-node-sandbox',
+        title: 'Command: SANDBOX_GET_RETURN_VALUE',
+        properties: {
+          command: 'SANDBOX_GET_RETURN_VALUE',
+        },
+        in: {
+          result: [
+            {
+              id: sandboxId,
+              port: 'result',
+            },
+          ],
+        },
+        out: {
+          result: (config.output
+            ? [
+                {
+                  id: config.output,
+                  port: 'change',
+                },
+              ]
+            : []
+          ).concat(
+            outputs.commandIdList.map((commandId) => ({
+              id: commandId,
+              port: 'obj',
+            })),
+          ),
+        },
+      },
+
+      ...(config.error && {
+        [config.error]: {
+          type: 'data-node',
+          properties: {},
+          in: {
+            change: [
+              {
+                id: sandboxErrorId,
+                port: 'result',
+              },
+            ],
+          },
+          out: {
+            value: null,
+          },
+        },
+      }),
+      ...(config.output && {
+        [config.output]: {
+          type: 'data-node',
+          properties: {},
+          in: {
+            change: [
+              {
+                id: sandboxResultId,
+                port: 'result',
+              },
+            ],
+          },
+          out: {
+            value: null,
+          },
+        },
+      }),
+      ...outputs.map,
+    },
+    editor_info: {
+      ...inputs.editorInfo,
+      [sandboxId]: {
+        position: { x: layerXInterval * 2, y: padding },
+        points: {},
+      },
+      [sandboxErrorId]: {
+        position: { x: layerXInterval * 2, y: layerYInterval },
+        points: {},
+      },
+      [sandboxResultId]: {
+        position: { x: layerXInterval * 2, y: layerYInterval * 2 },
+        points: {},
+      },
+      ...(config.error && {
+        [config.error]: {
+          position: { x: layerXInterval * 2, y: layerYInterval * 3 },
+          points: {},
+        },
+      }),
+      ...(config.output && {
+        [config.output]: {
+          position: { x: layerXInterval * 2, y: layerYInterval * 4 },
+          points: {},
+        },
+      }),
+      ...outputs.editorInfo,
+    },
+  }
+}

package/index.ts

@@ -0,0 +1,10 @@
+export * from './types'
+
+import { DataLink, Data } from './types'
+
+export { makeId } from './uuid'
+
+export const linkData: ((dataGetter: () => Data) => DataLink) = (dataGetter) => ({
+  __typename: 'DataLink',
+  data: dataGetter,
+})

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@fugood/bricks-project",
+  "version": "2.21.0-beta.14.test0",
+  "main": "index.ts",
+  "scripts": {
+    "build": "node scripts/build.js"
+  },
+  "dependencies": {
+    "acorn": "^8.13.0",
+    "escodegen": "^2.1.0",
+    "lodash": "^4.17.4",
+    "uuid": "^8.3.1"
+  },
+  "devDependencies": {}
+}

package/types/animation.ts

@@ -0,0 +1,95 @@
+export type Easing =
+  | ''
+  | 'easeInSine'
+  | 'easeOutSine'
+  | 'easeInOutSine'
+  | 'easeInQuad'
+  | 'easeOutQuad'
+  | 'easeInOutQuad'
+  | 'easeInCubic'
+  | 'easeOutCubic'
+  | 'easeInOutCubic'
+  | 'easeInQuart'
+  | 'easeOutQuart'
+  | 'easeInOutQuart'
+  | 'easeInQuint'
+  | 'easeOutQuint'
+  | 'easeInOutQuint'
+  | 'easeInExpo'
+  | 'easeOutExpo'
+  | 'easeInOutExpo'
+  | 'easeInCirc'
+  | 'easeOutCirc'
+  | 'easeInOutCirc'
+  | 'easeInBack'
+  | 'easeOutBack'
+  | 'easeInOutBack'
+  | 'easeInElastic'
+  | 'easeOutElastic'
+  | 'easeInOutElastic'
+  | 'easeInBounce'
+  | 'easeOutBounce'
+  | 'easeInOutBounce'
+
+export interface AnimationTimingConfig {
+  __type: 'AnimationTimingConfig'
+  toValue: number // BRICKS Grid unit
+  duration: number // ms
+  easing: Easing
+  delay: number // ms
+  isInteraction: boolean
+}
+
+export interface AnimationSpringConfig {
+  __type: 'AnimationSpringConfig'
+  toValue: number // BRICKS Grid unit
+  friction: number
+  tension: number
+  speed: number
+  bounciness: number
+}
+
+export interface AnimationDecayConfig {
+  __type: 'AnimationDecayConfig'
+  toValue: number // BRICKS Grid unit
+  velocity: number
+  deceleration: number
+  isInteraction: boolean
+}
+
+export interface AnimationDef {
+  __typename: 'Animation'
+  id: string
+  title: string
+  description?: string
+  runType?: 'once' | 'loop'
+  property:
+    | 'transform.translateX'
+    | 'transform.translateY'
+    | 'transform.scale'
+    | 'transform.scaleX'
+    | 'transform.scaleY'
+    | 'transform.rotate'
+    | 'transform.rotateX'
+    | 'transform.rotateY'
+    | 'opacity'
+  config: AnimationTimingConfig | AnimationSpringConfig | AnimationDecayConfig
+}
+
+export interface AnimationComposeDef {
+  __typename: 'AnimationCompose'
+  id: string
+  title: string
+  description?: string
+  runType?: 'once' | 'loop'
+  composeType: 'parallel' | 'sequence'
+  items: Array<() => AnimationDef>
+}
+
+export type Animation = AnimationDef | AnimationComposeDef
+
+export interface AnimationBasicEvents {
+  show?: Animation
+  standby?: Animation
+  breatheStart?: Animation
+}