@symbo.ls/cli 2.33.27 → 2.33.28

package/bin/collab.js

@@ -275,10 +275,77 @@ export async function startCollab(options) {
     }
   }
 
+  /**
+   * Augment the loaded project object with any new items that exist as
+   * filesystem files (e.g. newly created component/page/method/function/snippet
+   * files) but are not yet present in the in‑memory data object.
+   *
+   * This bridges the gap between the one‑way createFs → files mapping so that
+   * adding a new file like components/MainFooter.js is seen as a new
+   * `components.MainFooter` data item and can be sent to the server.
+   */
+  async function augmentLocalWithNewFsItems(local) {
+    if (!local || typeof local !== 'object') return
+
+    const TYPES = ['components', 'pages', 'snippets', 'methods', 'functions']
+
+    for (let i = 0; i < TYPES.length; i++) {
+      const type = TYPES[i]
+      const srcDir = path.join(distDir, type)
+
+      let entries
+      try {
+        entries = await fs.promises.readdir(srcDir)
+      } catch {
+        continue
+      }
+      if (!Array.isArray(entries) || !entries.length) continue
+
+      const container = local[type] && typeof local[type] === 'object' && !Array.isArray(local[type])
+        ? local[type]
+        : (local[type] = {})
+      const baseSection = currentBase && currentBase[type] && typeof currentBase[type] === 'object'
+        ? currentBase[type]
+        : {}
+
+      for (let j = 0; j < entries.length; j++) {
+        const filename = entries[j]
+        if (!filename.endsWith('.js') || filename === 'index.js') continue
+
+        const key = filename.slice(0, -3)
+        if (Object.prototype.hasOwnProperty.call(container, key)) continue
+        if (Object.prototype.hasOwnProperty.call(baseSection, key)) continue
+
+        const compiledPath = path.join(outputDir, type, filename)
+        let mod
+        try {
+          const { loadModule } = await import('./require.js')
+          mod = await loadModule(compiledPath, { silent: true })
+        } catch {
+          if (options.verbose) {
+            console.error(`Failed to load new ${type} item from`, compiledPath)
+          }
+          continue
+        }
+
+        if (!mod) continue
+
+        let value = null
+        if (mod && typeof mod === 'object') {
+          value = mod.default || mod[key] || null
+        }
+        if (!value || typeof value !== 'object') continue
+
+        container[key] = value
+      }
+    }
+  }
+
   const sendLocalChanges = debounce(async () => {
     if (suppressLocalChanges) return
     const local = await loadLocalProject()
     if (!local) return
+    await augmentLocalWithNewFsItems(local)
     // Prepare safe, JSON-serialisable snapshots for diffing & transport
     const base = currentBase || {}
     const safeBase = stringifyFunctionsForTransport(base)
@@ -294,6 +361,25 @@ export async function startCollab(options) {
     const { granularChanges } = preprocessChanges(safeBase, changes)
     const orders = computeOrdersForTuples(safeLocal, granularChanges)
     console.log(chalk.gray(`Emitting local ops: ${JSON.stringify({ changes, granularChanges, orders, branch })}`))
+
+    // Optimistically apply our own ops to the in-memory base so that
+    // subsequent diffs are computed against the latest local state.
+    // This avoids repeatedly re-emitting the same changes when the
+    // server does not immediately send back a fresh snapshot.
+    try {
+      const tuplesToApply = Array.isArray(granularChanges) && granularChanges.length
+        ? granularChanges
+        : changes
+      applyTuples(currentBase, tuplesToApply)
+      if (Array.isArray(orders) && orders.length) {
+        applyOrders(currentBase, orders)
+      }
+    } catch (e) {
+      if (options.verbose) {
+        console.error('Failed to apply local ops to in-memory base', e)
+      }
+    }
+
     socket.emit('ops', {
       changes,
       granularChanges,

package/helpers/changesUtils.js

@@ -1,11 +1,16 @@
+import * as utils from '@domql/utils'
 import { normalizeKeys } from './compareUtils.js'
 
+const { objectToString } = utils.default || utils
+
 // Keys managed by the CLI filesystem representation (exclude settings/schema/key/thumbnail/etc.)
 export const DATA_KEYS = [
   'designSystem','components','state','pages','snippets',
   'methods','functions','dependencies','files'
 ]
 
+const SCHEMA_CODE_TYPES = new Set(['pages', 'components', 'functions', 'methods', 'snippets'])
+
 function stripMetaDeep(val) {
   if (Array.isArray(val)) {
     return val.map(stripMetaDeep)
@@ -61,9 +66,12 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
 
   // Generate per-item granular changes one level deeper for each data type.
   // Ignore 'schema' comparisons; manage schema side-effects below.
+  const baseSchema = a?.schema || {}
+
   for (const typeKey of [...keys]) {
     const aSection = a?.[typeKey] || {}
     const bSection = b?.[typeKey] || {}
+    const aSchemaSection = baseSchema?.[typeKey] || {}
 
     // If sections are not plain objects (or are arrays), fallback to coarse replacement on the section itself
     const aIsObject = aSection && typeof aSection === 'object' && !Array.isArray(aSection)
@@ -90,11 +98,17 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
     for (const itemKey of Object.keys(bSection)) {
       const aVal = aSection[itemKey]
       const bVal = bSection[itemKey]
-      if (aVal === undefined) {
+      const hadPrev = typeof aVal !== 'undefined'
+      if (!hadPrev) {
         // New item
         changes.push(['update', [typeKey, itemKey], bVal])
-        // Ensure any stale schema code is removed (safety)
-        changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+        const hadSchema = aSchemaSection && Object.prototype.hasOwnProperty.call(aSchemaSection, itemKey)
+        if (SCHEMA_CODE_TYPES.has(typeKey) && !hadSchema) {
+          const schemaItem = buildSchemaItemFromData(typeKey, itemKey, bVal)
+          if (schemaItem) {
+            changes.push(['update', ['schema', typeKey, itemKey], schemaItem])
+          }
+        }
       } else if (!equal(aVal, bVal)) {
         // Updated item
         changes.push(['update', [typeKey, itemKey], bVal])
@@ -112,8 +126,18 @@ export function threeWayRebase(base, local, remote, keys = DATA_KEYS) {
   const theirsKeys = computeChangedKeys(base, remote, keys)
   const conflicts = oursKeys.filter(k => theirsKeys.includes(k))
 
-  const ours = computeCoarseChanges(base, local, keys).filter(([_, [k]]) => oursKeys.includes(k))
-  const theirs = computeCoarseChanges(base, remote, keys).filter(([_, [k]]) => theirsKeys.includes(k))
+  const allOurs = computeCoarseChanges(base, local, keys)
+  const allTheirs = computeCoarseChanges(base, remote, keys)
+
+  const ownsKey = (path, set) => {
+    if (!Array.isArray(path) || !path.length) return false
+    const [rootKey, typeKey] = path
+    const primary = rootKey === 'schema' ? typeKey : rootKey
+    return set.includes(primary)
+  }
+
+  const ours = allOurs.filter(([, path]) => ownsKey(path, oursKeys))
+  const theirs = allTheirs.filter(([, path]) => ownsKey(path, theirsKeys))
 
   let finalChanges = []
   if (conflicts.length === 0) {
@@ -224,6 +248,13 @@ function normaliseSchemaCode(code) {
     .replaceAll('/////tilde', '`')
 }
 
+function encodeSchemaCode(code) {
+  if (typeof code !== 'string' || !code.length) return ''
+  return code
+    .replaceAll('\n', '/////n')
+    .replaceAll('`', '/////tilde')
+}
+
 function parseExportedObject(code) {
   const src = normaliseSchemaCode(code)
   if (!src) return null
@@ -236,6 +267,46 @@ function parseExportedObject(code) {
   }
 }
 
+export function buildSchemaCodeFromObject(obj) {
+  if (!obj || typeof obj !== 'object') return ''
+  const body = objectToString(obj, 2)
+  const src = `export default ${body}`
+  return encodeSchemaCode(src)
+}
+
+function buildSchemaItemFromData(type, key, value) {
+  const schemaType = type
+
+  const base = {
+    title: key,
+    key,
+    type: schemaType
+  }
+
+  if (['pages', 'components'].includes(schemaType)) {
+    base.settings = {
+      gridOptions: {}
+    }
+    base.props = {}
+    base.interactivity = []
+    base.dataTypes = []
+    base.error = null
+  }
+
+  if (SCHEMA_CODE_TYPES.has(schemaType)) {
+    try {
+      const code = buildSchemaCodeFromObject(value)
+      if (code) {
+        base.code = code
+      }
+    } catch (_) {
+      // Fallback: omit code field if serialisation fails
+    }
+  }
+
+  return base
+}
+
 function extractTopLevelKeysFromCode(code) {
   const obj = parseExportedObject(code)
   if (!obj || typeof obj !== 'object') return []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/cli",
-  "version": "2.33.27",
+  "version": "2.33.28",
   "description": "Fetch your Symbols configuration",
   "main": "bin/fetch.js",
   "author": "Symbols",
@@ -15,9 +15,9 @@
     "vpatch": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@symbo.ls/fetch": "^2.33.27",
-    "@symbo.ls/init": "^2.33.27",
-    "@symbo.ls/socket": "^2.33.27",
+    "@symbo.ls/fetch": "^2.33.28",
+    "@symbo.ls/init": "^2.33.28",
+    "@symbo.ls/socket": "^2.33.28",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
@@ -28,5 +28,5 @@
     "socket.io-client": "^4.8.1",
     "v8-compile-cache": "^2.4.0"
   },
-  "gitHead": "305c78c0cd824b365d3e464dc3ede6b250c8baf1"
+  "gitHead": "58b2f9f34b228712ccc4352e15913c52d6007afb"
 }