@fugood/bricks-project 2.21.0-beta.14.test5 → 2.21.0-beta.14.test7

package/index.ts

@@ -1,10 +1,5 @@
 export type * from './types'
 
-import type { DataLink, Data } from './types'
-
-export { makeId } from './uuid'
-
-export const linkData: ((dataGetter: () => Data) => DataLink) = (dataGetter) => ({
-  __typename: 'DataLink',
-  data: dataGetter,
-})
+export { makeId } from './utils/id'
+export { generateDataCalculationMapEditorInfo } from './utils/calc'
+export { linkData, useSystemData } from './utils/data'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.21.0-beta.14.test5",
+  "version": "2.21.0-beta.14.test7",
   "main": "index.ts",
   "scripts": {
     "build": "node scripts/build.js"

package/tools/deploy.ts

@@ -0,0 +1,24 @@
+import { $ } from 'bun'
+import { deployApp, deployModule } from '../api'
+
+const cwd = process.cwd()
+
+const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+if (unstagedChanges) throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
+
+const commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+const app = await Bun.file(`${cwd}/application.json`).json()
+const stage = app.stage || 'production'
+const config = await Bun.file(`${cwd}/.bricks/build/application-config.json`).json()
+
+// ask for confirmation
+const confirm = prompt('Are you sure you want to deploy? (y/n)')
+if (confirm !== 'y') throw new Error('Deployment cancelled')
+
+if (!app.type || app.type === 'application') {
+  await deployApp(stage, app.id, config, commitId)
+  console.log('App deployed')
+} else if (app.type === 'module') {
+  await deployModule(stage, app.id, config, commitId)
+  console.log('Module deployed')
+}

package/tools/postinstall.ts

@@ -0,0 +1,12 @@
+import { $ } from 'bun'
+
+const cwd = process.cwd()
+
+const libFiles = ['types', 'utils', 'index.ts']
+
+await $`mkdir -p ${cwd}/project`
+for (const file of libFiles) {
+  await $`cp -r ${__dirname}/../${file} ${cwd}/project`
+}
+
+console.log('Copied files to project/')

package/tools/preview-main.mjs

@@ -1,15 +1,18 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
 import { app, BrowserWindow } from 'electron'
 import { readFile } from 'fs/promises'
 import { watchFile } from 'fs'
 
-let config = JSON.parse(await readFile(process.cwd() + '/.bricks/build/application-config.json'))
+const cwd = process.cwd()
+
+let config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
 
 const stage = process.env.BRICKS_STAGE || 'production'
 
 const previewUrlMap = {
   production: 'https://control.bricks.tools/applicationPreview.html',
   beta: 'https://control-beta.bricks.tools/applicationPreview.html',
-  dev: 'http://localhost:3006/dev-applicationPreview.html',
+  development: 'http://localhost:3006/dev-applicationPreview.html',
 }
 
 const previewUrl = previewUrlMap[stage]
@@ -33,7 +36,7 @@ app.on('ready', () => {
   mainWindow.webContents.once('dom-ready', sendConfig)
 
   watchFile(
-    process.cwd() + '/.bricks/build/application-config.json',
+    `${cwd}/.bricks/build/application-config.json`,
     {
       bigint: false,
       persistent: true,
@@ -41,7 +44,7 @@ app.on('ready', () => {
     },
     async () => {
       console.log('Detected config changed')
-      config = JSON.parse(await readFile(process.cwd() + '/.bricks/build/application-config.json'))
+      config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
       sendConfig()
     },
   )

package/tools/preview.ts

@@ -1,20 +1,37 @@
-import { $, main } from 'bun'
-import { watch, readFile } from 'fs'
+import { $ } from 'bun'
+import { watch } from 'fs'
+import { parseArgs } from 'util'
 import { debounce } from 'lodash'
 
-const app = await Bun.file(process.cwd() + '/application.json').json()
+const { values } = parseArgs({
+  args: Bun.argv,
+  options: {
+    'skip-typecheck': {
+      type: 'boolean',
+    },
+  },
+  strict: true,
+  allowPositionals: true,
+})
+
+const useTypecheck = !values['skip-typecheck']
 
-const compile = debounce(async () => {
+const compile = async () => {
+  if (useTypecheck) await $`bun typecheck`
   await $`bun compile`
-}, 500)
-
-watch(
-  process.cwd() + '/subspaces',
-  { recursive: true },
-  async (event, filename) => {
-    console.log(`Detected ${event} in ${filename}`)
-    compile()
-  },
-)
+}
+
+await compile()
+
+const compileDebounced = debounce(compile, 500)
+
+const cwd = process.cwd()
+
+watch(`${cwd}/subspaces`, { recursive: true }, async (event, filename) => {
+  console.log(`Detected ${event} in ${filename}`)
+  compileDebounced()
+})
+
+const app = await Bun.file(`${cwd}/application.json`).json()
 
 await $`BRICKS_STAGE=${app.stage || 'production'} bunx electron ${__dirname}/preview-main.mjs`

package/tools/pull.ts

@@ -0,0 +1,51 @@
+import { $ } from 'bun'
+import { format } from 'prettier'
+import { pullApplicationProject, pullModuleProject } from '../api'
+
+const cwd = process.cwd()
+
+const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+if (unstagedChanges)
+  throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
+
+const app = await Bun.file(`${cwd}/application.json`).json()
+const stage = app.stage || 'production'
+const { files, lastCommitId } =
+  app.type === 'module'
+    ? await pullModuleProject(stage, app.id)
+    : await pullApplicationProject(stage, app.id)
+
+const found = (await $`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
+  .trim()
+  .match(/^[a-f0-9]{40}$/)
+
+const commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+
+if (commitId === lastCommitId) throw new Error('Commit not changed')
+
+const branchName = 'BRICKS_PROJECT_try-pull-application'
+
+await $`cd ${cwd} && git branch -D ${branchName}`.nothrow()
+
+let useMain = false
+if (found) {
+  await $`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
+} else {
+  await $`cd ${cwd} && git checkout -b ${branchName}`
+  useMain = true
+}
+
+await Promise.all(
+  files.map(async (file) =>
+    Bun.write(
+      `${cwd}/${file.name}`,
+      file.formatable ? await format(file.input, { parser: 'typescript' }) : file.input,
+    ),
+  ),
+)
+
+await $`cd ${cwd} && git add .`
+await $`cd ${cwd} && git commit -m 'Apply ${app.name} file changes'`
+if (!useMain) {
+  await $`cd ${cwd} && git merge main`
+}

package/types/common.ts

@@ -12,7 +12,7 @@ export interface Brick {
   events: {}
   outlets?: {}
   animation?: {}
-  switches: Array<SwitchDef>
+  switches?: Array<SwitchDef>
 }
 
 export enum LocalSyncStrategy {
@@ -30,7 +30,7 @@ export interface Generator {
   property?: {}
   events: {}
   outlets?: {}
-  switches: Array<SwitchDef>
+  switches?: Array<SwitchDef>
 }
 
 export type SubspaceID = string
@@ -103,7 +103,7 @@ export type ApplicationSettings = {
       borderBottomLeftRadius?: number
       borderBottomRightRadius?: number
     }
-  },
+  }
 }
 
 export type Application = {

package/types/switch.ts

@@ -36,10 +36,13 @@ export interface SwitchDef {
   animation?: {}
   conds?: Array<{
     method: '==' | '!=' | '>' | '<' | '>=' | '<='
-    cond: SwitchCondInnerStateCurrentCanvas | SwitchCondData | {
-      __typename: 'SwitchCondInnerStateOutlet'
-      outlet: string
-      value: any
-    }
+    cond:
+      | SwitchCondInnerStateCurrentCanvas
+      | SwitchCondData
+      | {
+          __typename: 'SwitchCondInnerStateOutlet'
+          outlet: string
+          value: any
+        }
   }>
 }

package/utils/calc.ts

@@ -0,0 +1,118 @@
+import type { DataCalculationMap, DataCalculationData, DataCommand } from '../types/data-calc'
+
+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>
+  >()
+
+  // Analyze node connections
+  nodes.forEach((node) => {
+    // Count and track inputs
+    if ('inputs' in node) {
+      const inputs = node.inputs
+        .filter((input) => input !== null)
+        .map((input) => (Array.isArray(input) ? input.length : 1))
+        .reduce((sum, count) => sum + count, 0)
+      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 = nodes.find((n) => 'id' in n && n.id === conn.id)
+            if (sourceNode) {
+              connectedTo.get(node)!.add(sourceNode)
+            }
+          })
+        }
+      })
+    } else {
+      inputCounts.set(node, 0)
+    }
+
+    // Count outputs
+    if ('outputs' in node) {
+      const outputs = node.outputs
+        .filter((output) => output !== null)
+        .map((output) => (Array.isArray(output) ? output.length : 1))
+        .reduce((sum, count) => sum + count, 0)
+      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
+}