@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.62

package/utils/__tests__/calc.test.js

@@ -1,25 +0,0 @@
-import { generateDataCalculationMapEditorInfo } from '../calc'
-
-describe('generateDataCalculationMapEditorInfo', () => {
-  test('indexes source nodes while resolving array input connections', () => {
-    const firstSource = { id: 'PROPERTY_BANK_DATA_NODE_first', title: 'First source' }
-    const secondSource = { id: 'PROPERTY_BANK_DATA_NODE_second', title: 'Second source' }
-    const command = {
-      id: 'PROPERTY_BANK_COMMAND_NODE_merge',
-      title: 'Merge values',
-      inputs: [
-        [
-          { id: firstSource.id, port: 'value' },
-          { id: secondSource.id, port: 'value' },
-          { id: 'PROPERTY_BANK_DATA_NODE_missing', port: 'value' },
-        ],
-      ],
-      outputs: [[{ id: firstSource.id, port: 'value' }]],
-    }
-
-    const editorInfo = generateDataCalculationMapEditorInfo([firstSource, secondSource, command])
-    const commandInfo = editorInfo.find((info) => info.node === command)
-
-    expect(commandInfo?.position.x).toBe(615)
-  })
-})

package/utils/__tests__/id.test.js

@@ -1,154 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { makeId } from '../id'
-
-const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
-const UUID_ONLY_RE = new RegExp(`^${UUID}$`)
-
-const withProjectDir = (app, fn) => {
-  const previousCwd = process.cwd()
-  const dir = mkdtempSync(join(tmpdir(), 'make-id-'))
-  try {
-    if (app) writeFileSync(join(dir, 'application.json'), JSON.stringify(app))
-    process.chdir(dir)
-    return fn()
-  } finally {
-    process.chdir(previousCwd)
-    rmSync(dir, { recursive: true, force: true })
-  }
-}
-
-describe('makeId', () => {
-  describe('type prefixes', () => {
-    const cases = [
-      ['animation', 'ANIMATION_'],
-      ['brick', 'BRICK_'],
-      ['dynamic-brick', 'DYNAMIC_BRICK_'],
-      ['canvas', 'CANVAS_'],
-      ['generator', 'GENERATOR_'],
-      ['data', 'PROPERTY_BANK_DATA_NODE_'],
-      ['switch', 'BRICK_STATE_GROUP_'],
-      ['property_bank_command', 'PROPERTY_BANK_COMMAND_NODE_'],
-      ['property_bank_calc', 'PROPERTY_BANK_COMMAND_MAP_'],
-      ['automation_map', 'AUTOMATION_MAP_'],
-      ['test', 'TEST_'],
-      ['test_case', 'TEST_CASE_'],
-      ['test_var', 'TEST_VAR_'],
-    ]
-
-    test.each(cases)('produces %p prefix', (type, prefix) => {
-      expect(makeId(type)).toMatch(new RegExp(`^${prefix}${UUID}$`))
-    })
-
-    test('uses generated count fallback when no alias is provided', () => {
-      const first = withProjectDir({ id: 'count-fallback-app' }, () => {
-        jest.resetModules()
-        const { makeId: makeFreshId } = require('../id')
-        return [makeFreshId('brick'), makeFreshId('brick')]
-      })
-      const second = withProjectDir({ id: 'count-fallback-app' }, () => {
-        jest.resetModules()
-        const { makeId: makeFreshId } = require('../id')
-        return [makeFreshId('brick'), makeFreshId('brick')]
-      })
-
-      expect(first[0]).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      expect(first[1]).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      expect(first[0]).not.toBe(first[1])
-      expect(second).toEqual(first)
-      jest.resetModules()
-    })
-
-    test('unknown type falls through to an unprefixed uuid', () => {
-      expect(makeId('not-a-real-type')).toMatch(UUID_ONLY_RE)
-    })
-  })
-
-  describe('subspace', () => {
-    test('throws because subspace IDs must be fixed', () => {
-      expect(() => makeId('subspace')).toThrow(/subspace is not supported/)
-    })
-  })
-
-  describe('snapshotMode', () => {
-    test('produces deterministic v4 uuids from the generated count', () => {
-      const previousCwd = process.cwd()
-      const dir = mkdtempSync(join(tmpdir(), 'make-id-snapshot-'))
-      writeFileSync(join(dir, 'application.json'), JSON.stringify({ id: 'snapshot-app' }))
-      try {
-        process.chdir(dir)
-        jest.resetModules()
-        const { makeId: makeFreshId } = require('../id')
-        const a = makeFreshId('brick', { snapshotMode: true })
-        const b = makeFreshId('brick', { snapshotMode: true })
-
-        jest.resetModules()
-        const { makeId: makeFreshIdAgain } = require('../id')
-        expect(makeFreshIdAgain('brick', { snapshotMode: true })).toBe(a)
-        expect(makeFreshIdAgain('brick', { snapshotMode: true })).toBe(b)
-        expect(a).not.toBe(b)
-        expect(a).toMatch(new RegExp(`^BRICK_${UUID}$`))
-        expect(b).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      } finally {
-        process.chdir(previousCwd)
-        rmSync(dir, { recursive: true, force: true })
-        jest.resetModules()
-      }
-    })
-
-    test('snapshotMode false falls back to random uuid', () => {
-      const id = makeId('canvas', { snapshotMode: false })
-      expect(id).toMatch(new RegExp(`^CANVAS_${UUID}$`))
-    })
-  })
-
-  describe('stable aliases', () => {
-    test('produces the same id for the same application id, type, and alias', () => {
-      const first = withProjectDir({ id: 'stable-app' }, () => {
-        jest.resetModules()
-        return require('../id').makeId('brick', 'stable-hero')
-      })
-      const second = withProjectDir({ id: 'stable-app' }, () => {
-        jest.resetModules()
-        return require('../id').makeId('brick', 'stable-hero')
-      })
-
-      expect(second).toBe(first)
-      expect(first).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      jest.resetModules()
-    })
-
-    test('uses the application id when hashing stable aliases', () => {
-      const idA = withProjectDir({ id: 'app-a' }, () => makeId('brick', 'hero'))
-      const idB = withProjectDir({ id: 'app-b' }, () => makeId('brick', 'hero'))
-
-      expect(idA).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      expect(idB).toMatch(new RegExp(`^BRICK_${UUID}$`))
-      expect(idA).not.toBe(idB)
-    })
-
-    test('rejects duplicate aliases for the same application id and entry type', () => {
-      withProjectDir({ id: 'duplicate-app' }, () => {
-        expect(makeId('brick', 'shared')).toMatch(new RegExp(`^BRICK_${UUID}$`))
-        expect(() => makeId('brick', 'shared')).toThrow(/Duplicate makeId alias 'shared'/)
-      })
-    })
-
-    test('allows the same alias for different entry types', () => {
-      withProjectDir({ id: 'shared-alias-app' }, () => {
-        const brick = makeId('brick', 'shared')
-        const canvas = makeId('canvas', 'shared')
-
-        expect(brick).toMatch(new RegExp(`^BRICK_${UUID}$`))
-        expect(canvas).toMatch(new RegExp(`^CANVAS_${UUID}$`))
-        expect(brick).not.toBe(canvas)
-      })
-    })
-
-    test('falls back when application.json is not present', () => {
-      const id = withProjectDir(null, () => makeId('brick', 'fallback-app-id'))
-      expect(id).toMatch(new RegExp(`^BRICK_${UUID}$`))
-    })
-  })
-})

package/utils/calc.ts

@@ -1,130 +0,0 @@
-import type {
-  DataCommand,
-  DataCalculationMap,
-  DataCalculationData,
-} from '../types/data-calc-command'
-
-const GRID = {
-  WIDTH: 300, // Distance between columns
-  HEIGHT: 150, // Distance between rows
-  PADDING: 15, // Edge padding
-  COLUMNS: 4, // Max columns in grid
-  ROWS: 3, // Max rows in grid
-}
-
-// TODO: Improve the algorithm to minimize crossing lines
-
-// If we are too lazy to describe nodes in the editing interface,
-// we can let it generate it automatically
-export const generateDataCalculationMapEditorInfo = (
-  nodes: Array<DataCalculationData | DataCommand>,
-) => {
-  const editorInfo: DataCalculationMap['editorInfo'] = []
-
-  // Track node relationships
-  const inputCounts = new Map<DataCalculationData | DataCommand, number>()
-  const outputCounts = new Map<DataCalculationData | DataCommand, number>()
-  const connectedTo = new Map<
-    DataCalculationData | DataCommand,
-    Set<DataCalculationData | DataCommand>
-  >()
-  const nodeById = new Map<string, DataCalculationData | DataCommand>()
-  for (const node of nodes) {
-    if ('id' in node) nodeById.set(node.id, node)
-  }
-
-  // Analyze node connections
-  nodes.forEach((node) => {
-    // Count and track inputs
-    if ('inputs' in node) {
-      let inputs = 0
-      for (const input of node.inputs) {
-        if (input === null) continue
-        if (Array.isArray(input)) inputs += input.length
-        else inputs += 1
-      }
-      inputCounts.set(node, inputs)
-
-      // Track connections
-      node.inputs.forEach((input) => {
-        if (Array.isArray(input)) {
-          input.forEach((conn) => {
-            if (!connectedTo.has(node)) {
-              connectedTo.set(node, new Set())
-            }
-            const sourceNode = nodeById.get(conn.id)
-            if (sourceNode) {
-              connectedTo.get(node)!.add(sourceNode)
-            }
-          })
-        }
-      })
-    } else {
-      inputCounts.set(node, 0)
-    }
-
-    // Count outputs
-    if ('outputs' in node) {
-      let outputs = 0
-      for (const output of node.outputs) {
-        if (output === null) continue
-        if (Array.isArray(output)) outputs += output.length
-        else outputs += 1
-      }
-      outputCounts.set(node, outputs)
-    } else {
-      outputCounts.set(node, 0)
-    }
-  })
-
-  // Calculate layers
-  const layers: Array<Array<DataCalculationData | DataCommand>> = [[], [], [], []]
-
-  nodes.forEach((node) => {
-    const inputs = inputCounts.get(node) || 0
-    const outputs = outputCounts.get(node) || 0
-    const connections = connectedTo.get(node)?.size || 0
-
-    if (inputs === 0) {
-      // Input nodes (leftmost)
-      layers[0].push(node)
-    } else if (outputs === 0) {
-      // Output nodes (rightmost)
-      layers[3].push(node)
-    } else if (connections > 1) {
-      // Nodes with multiple connections (middle-right)
-      layers[2].push(node)
-    } else {
-      // Processing nodes (middle-left)
-      layers[1].push(node)
-    }
-  })
-
-  // Position nodes in each layer
-  layers.forEach((layerNodes, layerIndex) => {
-    // Sort nodes by their connections to try to minimize crossing lines
-    layerNodes.sort((a, b) => {
-      const aConns = connectedTo.get(a)?.size || 0
-      const bConns = connectedTo.get(b)?.size || 0
-      return bConns - aConns
-    })
-
-    // Position nodes in the layer
-    layerNodes.forEach((node, nodeIndex) => {
-      // Distribute nodes evenly within their layer
-      const row = nodeIndex % GRID.ROWS
-      const offset = Math.floor(nodeIndex / GRID.ROWS) * (GRID.HEIGHT / 2)
-
-      editorInfo.push({
-        node,
-        position: {
-          x: GRID.PADDING + layerIndex * GRID.WIDTH,
-          y: GRID.PADDING + row * GRID.HEIGHT + offset,
-        },
-        points: [],
-      })
-    })
-  })
-
-  return editorInfo
-}