@fugood/bricks-project 2.25.0-beta.22 → 2.25.0-beta.23

package/compile/index.ts

@@ -1194,7 +1194,7 @@ export const compile = async (app: Application) => {
             ...compileRemoteUpdate(data.remoteUpdate),
             routing: data.routing,
             schema: data.schema,
-            type: data.type,
+            type: data.type === 'boolean' ? 'bool' : data.type,
             ...compileKind(data.kind),
             value: compileProperty(data.value, `(data: ${dataId}, subspace ${subspaceId})`),
             event_map: compileEvents('PROPERTY_BANK', data.events || {}, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.22",
+  "version": "2.25.0-beta.23",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",

package/package.json.bak

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.22",
+  "version": "2.25.0-beta.23",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",

package/skills/bricks-ctor/rules/data-calculation.md

@@ -182,6 +182,8 @@ const triggerCalc: EventAction = {
 }
 ```
 
+When the same chain writes a calc input (e.g. `PROPERTY_BANK` setting `dLastButton`) then issues `PROPERTY_BANK_COMMAND`, set `waitAsync: true` on the write so the calc reads the new value rather than the pre-chain snapshot. See [Event Action Chains](architecture-patterns.md#event-action-chains-priority-2).
+
 ## Best Practices
 
 1. **Avoid circular deps**: Set non-triggering inputs (`trigger: false`) or use `manual` mode

package/tools/_shell.ts

@@ -29,6 +29,7 @@ class Sh implements PromiseLike<ShResult> {
   private _cwd: string | undefined
   private _mode: Mode = 'default'
   private _throw = true
+  private _env: NodeJS.ProcessEnv | undefined
   private _promise: Promise<ShResult> | null = null
 
   constructor(private readonly args: string[]) {}
@@ -48,6 +49,11 @@ class Sh implements PromiseLike<ShResult> {
     return this
   }
 
+  env(extra: NodeJS.ProcessEnv): this {
+    this._env = { ...this._env, ...extra }
+    return this
+  }
+
   async text(): Promise<string> {
     // If no explicit quiet was requested, capture stdout/stderr without
     // forwarding them to the parent's streams (matches Bun's `.text()`).
@@ -79,7 +85,8 @@ class Sh implements PromiseLike<ShResult> {
           ? ['ignore', 'pipe', 'pipe']
           : ['inherit', 'pipe', 'pipe']
 
-    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio })
+    const env = this._env ? { ...process.env, ...this._env } : undefined
+    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio, env })
 
     const outChunks: Buffer[] = []
     const errChunks: Buffer[] = []

package/tools/mcp-tools/compile.ts

@@ -3,16 +3,21 @@ import { readFile } from 'node:fs/promises'
 import { z } from 'zod'
 import { sh } from '../_shell'
 
+// Disable ANSI color codes from spawned tools so MCP text output stays readable
+// (the host renders raw text; escape sequences leak into the result otherwise).
+const noColorEnv = { FORCE_COLOR: '0', NO_COLOR: '1' }
+
 export function register(server: McpServer, projectDir: string) {
   const { dirname } = import.meta
 
   server.tool('compile', {}, async () => {
-    let log = ''
+    let log = 'Type checking & Compiling...\n'
     try {
-      log += 'Type checking & Compiling...'
-      log += await sh`bun compile`.cwd(projectDir).text()
-    } catch (err) {
-      log += `${err.stdout.toString()}\n${err.stderr.toString()}`
+      log += await sh`bun compile`.cwd(projectDir).env(noColorEnv).text()
+    } catch (err: any) {
+      const stdout = err.stdout?.toString() ?? ''
+      const stderr = err.stderr?.toString() ?? ''
+      log += [stdout, stderr].filter(Boolean).join('\n')
     }
     return {
       content: [{ type: 'text', text: log }],
@@ -65,9 +70,12 @@ export function register(server: McpServer, projectDir: string) {
         if (testTitleLike) args.push('--test-title-like', testTitleLike)
         log = await sh`bunx --bun electron ${toolsDir}/preview-main.mjs ${args}`
           .cwd(projectDir)
+          .env(noColorEnv)
           .text()
-      } catch (err) {
-        log = `${err.stdout.toString()}\n${err.stderr.toString()}`
+      } catch (err: any) {
+        const stdout = err.stdout?.toString() ?? ''
+        const stderr = err.stderr?.toString() ?? ''
+        log = [stdout, stderr].filter(Boolean).join('\n')
         error = true
       }
       let screenshotBase64: string | null = null

package/tools/mcp-tools/media.ts

@@ -2,9 +2,12 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
 import { sh } from '../_shell'
 
+// MCP results are rendered as raw text — disable ANSI colors from the child.
+const noColorEnv = { FORCE_COLOR: '0', NO_COLOR: '1' }
+
 const runBricks = async (projectDir: string, ...args: string[]) => {
   try {
-    return await sh`bunx bricks ${args}`.cwd(projectDir).text()
+    return await sh`bunx bricks ${args}`.cwd(projectDir).env(noColorEnv).text()
   } catch (err: any) {
     throw new Error(err.stderr?.toString() || err.message)
   }

package/types/common.ts

@@ -12,7 +12,7 @@ export interface Brick {
   description?: string
   hideShortRef?: boolean
   property?: {}
-  events: {}
+  events?: {}
   outlets?: {}
   animation?: {}
   switches?: Array<SwitchDef>
@@ -33,7 +33,7 @@ export interface Generator {
   hideShortRef?: boolean
   localSyncRunMode?: LocalSyncStrategy
   property?: {}
-  events: {}
+  events?: {}
   outlets?: {}
   switches?: Array<SwitchDef>
 }

package/types/data-calc-command/base.ts

@@ -0,0 +1,57 @@
+/* Auto generated by build script */
+import type { Data } from '../data'
+import type { DataCalculation } from '../data-calc'
+
+// Shared helpers — every generated DataCommand{Name} reuses these to describe
+// its narrowed inputs/outputs, so the per-command files stay short.
+export type DataCalcInput<K extends string = string, T = any> = {
+  key: K
+  source: (() => DataCalculationData | DataCommand) | T
+  sourceKey: string
+  trigger?: boolean
+}
+
+export type DataCalcOutput<K extends string = string> = {
+  key: K
+  target: () => DataCalculationData | DataCommand
+  targetKey: string
+}
+
+export interface DataCalculationData {
+  __typename: 'DataCalculationData'
+  title?: string
+  description?: string
+  hideShortRef?: boolean
+  data: () => Data
+  // 'change' is the only valid input port on a data node; the source must be
+  // another node (no inline literals), hence `never` for the second type arg.
+  inputs: Array<DataCalcInput<'change', never>>
+  outputs: Array<DataCalcOutput<'value'>>
+}
+
+export interface DataCommand {
+  __typename: 'DataCommand'
+  __commandName: string
+  id: string
+  title?: string
+  description?: string
+  hideShortRef?: boolean
+  inputs: Array<DataCalcInput>
+  outputs: Array<DataCalcOutput>
+}
+
+export type DataCalculationMap = DataCalculation & {
+  __typename: 'DataCalculationMap'
+  nodes: Array<DataCalculationData | DataCommand>
+  editorInfo: Array<{
+    node: DataCalculationData | DataCommand
+    position: { x: number; y: number }
+    points: Array<{
+      source: DataCalculationData | DataCommand
+      sourceOutputKey: string
+      target: DataCalculationData | DataCommand
+      targetInputKey: string
+      positions: Array<{ x: number; y: number }>
+    }>
+  }>
+}

package/types/data-calc-command/collection.ts

@@ -0,0 +1,418 @@
+/* Auto generated by build script */
+import type { DataCalculationData, DataCommand, DataCalcInput, DataCalcOutput } from './base'
+
+/* Compact — Remove false, undefined, 0, "", undefined, NaN in array */
+export type DataCommandCollectionCompact = DataCommand & {
+  __commandName: 'COLLECTION_COMPACT'
+  inputs?: Array<DataCalcInput<'collection', Array<any>> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Concat — Concat object or array. Return empty array if no var provided. */
+export type DataCommandCollectionConcat = DataCommand & {
+  __commandName: 'COLLECTION_CONCAT'
+  inputs?: Array<
+    | DataCalcInput<'var1', any> /* default: [] */
+    | DataCalcInput<'var2', any> /* default: [] */
+    | DataCalcInput<'var3', any> /* default: [] */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Count — Group the contents of arrays or objects and output individual counts.
+If group_by_path provided, it will use value from path to group, use whole value as key if path is empty string, then output to result.
+If group_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_group, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionCount = DataCommand & {
+  __commandName: 'COLLECTION_COUNT'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'group_by_path', string> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_group',
+        string
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: object */
+  >
+}
+
+/* Difference — Creates an array of array values not included in the other given arrays. */
+export type DataCommandCollectionDifference = DataCommand & {
+  __commandName: 'COLLECTION_DIFFERENCE'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'values', Array<any>> /* default: [] */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Drop — Drop values with number in array or object. */
+export type DataCommandCollectionDrop = DataCommand & {
+  __commandName: 'COLLECTION_DROP'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'number', any> /* default: 1 */
+    | DataCalcInput<'forward', boolean> /* default: true */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Every — Whether all the contents in the array or object meet the conditions.
+If predicate provided, it will use LOGICTYPE_EQUAL_VALUE to compare, then output to result.
+If predicate not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_valid, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionEvery = DataCommand & {
+  __commandName: 'COLLECTION_EVERY'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'predicate', object> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_valid',
+        boolean
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: boolean */
+  >
+}
+
+/* Fill — Fill value in array with length.  Example: COLLECTION_FILL(start=2, length=2, value='A')  Result：[undefined, undefined, 'A', 'A'] */
+export type DataCommandCollectionFill = DataCommand & {
+  __commandName: 'COLLECTION_FILL'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'start', any> /* default: 0 */
+    | DataCalcInput<'length', any> /* default: length to end of array */
+    | DataCalcInput<'value', any> /* default: undefined */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Filter — Filter the content that meets the conditions in the array or object.
+If predicate provided, it will use LOGICTYPE_EQUAL_VALUE to compare, then output to result.
+If predicate not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_valid, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionFilter = DataCommand & {
+  __commandName: 'COLLECTION_FILTER'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'predicate', object> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_valid',
+        boolean
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Find — Find first value by condition in array.
+If predicate provided, it will use LOGICTYPE_EQUAL_VALUE to compare, then output to result.
+If predicate not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_valid, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionFind = DataCommand & {
+  __commandName: 'COLLECTION_FIND'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'predicate', object> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_valid',
+        boolean
+      > /* iteratee callback input */ /* default: undefined */
+    | DataCalcInput<'forward', boolean> /* default: true */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Find Key — Find key of first value by condition in array.
+If predicate provided, it will use LOGICTYPE_EQUAL_VALUE to compare, then output to result.
+If predicate not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_valid, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionFindKey = DataCommand & {
+  __commandName: 'COLLECTION_FIND_KEY'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'predicate', object> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_valid',
+        boolean
+      > /* iteratee callback input */ /* default: undefined */
+    | DataCalcInput<'forward', boolean> /* default: true */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* First — Get first value in array */
+export type DataCommandCollectionFirst = DataCommand & {
+  __commandName: 'COLLECTION_FIRST'
+  inputs?: Array<DataCalcInput<'array', Array<any>> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Flatten — Flatten a single level deep or recursively deep. */
+export type DataCommandCollectionFlatten = DataCommand & {
+  __commandName: 'COLLECTION_FLATTEN'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'deep', boolean> /* default: true */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Group By — Group array elements or object attributes into groups and generate objects.
+If group_by_path provided, it will use value from path to group, use whole value as key if path is empty string, then output to result.
+If group_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_group, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionGroupBy = DataCommand & {
+  __commandName: 'COLLECTION_GROUP_BY'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'group_by_path', string> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_group',
+        string
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: object */
+  >
+}
+
+/* Includes — Check value in array. */
+export type DataCommandCollectionIncludes = DataCommand & {
+  __commandName: 'COLLECTION_INCLUDES'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'value', any> /* default: undefined */
+    | DataCalcInput<'from_index', any> /* default: 0 */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: boolean */>
+}
+
+/* Intersection — Get arrays intersection.
+If intersection_by_path provided, it will use value from path to intersect, use whole value as key if path is empty string, then output to result.
+If intersection_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_value, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionIntersection = DataCommand & {
+  __commandName: 'COLLECTION_INTERSECTION'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'intersection_by_path', string> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_value',
+        any
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Key By — Use the specified value as the property name of the new object.
+If key_by_path provided, it will use value from path as key, use whole value as key if path is empty string, then output to result.
+If key_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_key, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionKeyBy = DataCommand & {
+  __commandName: 'COLLECTION_KEY_BY'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'key_by_path', string> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_key',
+        string
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: object */
+  >
+}
+
+/* Last — Get last value of array. */
+export type DataCommandCollectionLast = DataCommand & {
+  __commandName: 'COLLECTION_LAST'
+  inputs?: Array<DataCalcInput<'array', Array<any>> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Map — Map to new array.
+If map_by_path provided, it will use value from path, use whole value if path is empty string, then output to result.
+If map_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_value, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionMap = DataCommand & {
+  __commandName: 'COLLECTION_MAP'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'map_by_path', string> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_value',
+        any
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Nth — Get N th value of array. */
+export type DataCommandCollectionNth = DataCommand & {
+  __commandName: 'COLLECTION_NTH'
+  inputs?: Array<
+    DataCalcInput<'array', Array<any>> /* default: [] */ | DataCalcInput<'n', any> /* default: 0 */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Push — Push value into array. */
+export type DataCommandCollectionPush = DataCommand & {
+  __commandName: 'COLLECTION_PUSH'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'forward', boolean> /* default: true */
+    | DataCalcInput<'var1', any> /* default: undefined */
+    | DataCalcInput<'var2', any> /* default: undefined */
+    | DataCalcInput<'var3', any> /* default: undefined */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Reduce — Reduce the array to a single result.
+It will trigger iteratee_input callback for every property (With { result, key, value }).  After the calculation triggered iteratee_result, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionReduce = DataCommand & {
+  __commandName: 'COLLECTION_REDUCE'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'initial_value', any> /* default: undefined */
+    | DataCalcInput<'iteratee_result', any> /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Reverse — Reverse array */
+export type DataCommandCollectionReverse = DataCommand & {
+  __commandName: 'COLLECTION_REVERSE'
+  inputs?: Array<DataCalcInput<'array', Array<any>> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Sample — Get N th value of array randomly. */
+export type DataCommandCollectionSample = DataCommand & {
+  __commandName: 'COLLECTION_SAMPLE'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'n', any> /* default: 0 */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Shuffie — Shuffie array order. */
+export type DataCommandCollectionShuffle = DataCommand & {
+  __commandName: 'COLLECTION_SHUFFLE'
+  inputs?: Array<DataCalcInput<'array', Array<any>> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Size — Get array size. */
+export type DataCommandCollectionSize = DataCommand & {
+  __commandName: 'COLLECTION_SIZE'
+  inputs?: Array<DataCalcInput<'collection', Array<any> | object> /* default: [] */>
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Slice — Slice array. */
+export type DataCommandCollectionSlice = DataCommand & {
+  __commandName: 'COLLECTION_SLICE'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'start', any> /* default: 0 */
+    | DataCalcInput<'end', any> /* default: Array length */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Some — Check whether any of the array or object property meets the conditions.
+If predicate provided, it will use LOGICTYPE_EQUAL_VALUE to compare, then output to result.
+If predicate not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_valid, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionSome = DataCommand & {
+  __commandName: 'COLLECTION_SOME'
+  inputs?: Array<
+    | DataCalcInput<'collection', Array<any> | object> /* default: [] */
+    | DataCalcInput<'predicate', object> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_valid',
+        boolean
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: boolean */
+  >
+}
+
+/* Sort — Sort array.
+If sort_by_path provided, it will use value from path to sort, use whole value if path is empty string, then output to result.
+If sort_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_value, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionSort = DataCommand & {
+  __commandName: 'COLLECTION_SORT'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'sort_by_path', string | Array<any>> /* default: undefined */
+    | DataCalcInput<
+        'iteratee_result_value',
+        any
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Take — Creates a slice of array with n elements taken from the beginning. */
+export type DataCommandCollectionTake = DataCommand & {
+  __commandName: 'COLLECTION_TAKE'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'n', any> /* default: 1 */
+    | DataCalcInput<'forward', boolean> /* default: true */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}
+
+/* Union — Creates an array of unique values, in order, from all given arrays.
+If union_by_path provided, it will use path to compare, then output to result.
+If union_by_path not provided, it will trigger iteratee_input callback for every property (With { key, value }).  After the calculation triggered iteratee_result_value, it will confirm whether to continue the next trigger of iteratee_input. Finally, it will trigger result output. */
+export type DataCommandCollectionUnion = DataCommand & {
+  __commandName: 'COLLECTION_UNION'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'union_by_path', string> /* default: "" */
+    | DataCalcInput<
+        'iteratee_result_value',
+        any
+      > /* iteratee callback input */ /* default: undefined */
+  >
+  outputs?: Array<
+    | DataCalcOutput<'iteratee_input'> /* iteratee callback */ /* target: object */
+    | DataCalcOutput<'result'> /* target: any */
+  >
+}
+
+/* Without — Creates an array excluding all given values. */
+export type DataCommandCollectionWithout = DataCommand & {
+  __commandName: 'COLLECTION_WITHOUT'
+  inputs?: Array<
+    | DataCalcInput<'array', Array<any>> /* default: [] */
+    | DataCalcInput<'exclude', Array<any>> /* default: [] */
+  >
+  outputs?: Array<DataCalcOutput<'result'> /* target: any */>
+}