@jointhedots/gear 1.1.15 → 1.1.17

package/browser-modules/asap-raw.js

@@ -38,7 +38,7 @@ function flush() {
     flushing = false;
 }
 
-var scope = typeof globalThis !== "undefined" ? globalThis : (typeof self !== "undefined" ? self : window);
+var scope = typeof globalThis !== "undefined" ? globalThis : (typeof self !== "undefined" ? self : globalThis);
 var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
 
 if (typeof BrowserMutationObserver === "function") {

package/browser-modules/process.js

@@ -227,7 +227,7 @@ const process = {
     config,
     uptime,
 }
-window.process = process
+globalThis.process = process
 
 export {
     nextTick,

package/browser-modules/side-effects.js

@@ -4,5 +4,214 @@
 import './process.js'
 import './buffer.js'
 
-// Make Buffer available globally
-globalThis.Buffer = Buffer
+// Add Node.js-specific API to W3C ReadableStream
+{
+   const proto = ReadableStream.prototype
+
+   // Start consuming the stream, emitting 'data'/'end'/'error'/'close' events
+   function _startReading(stream) {
+      if (stream._reading) return
+      stream._reading = true
+      stream._paused = false
+      const reader = stream.getReader()
+      const pump = () => reader.read().then(({ done, value }) => {
+         if (done) {
+            stream._reading = false
+            stream._emit('end')
+            stream._emit('close')
+            return
+         }
+         stream._emit('data', value)
+         if (!stream._paused) return pump()
+         stream._pump = pump
+      }).catch(err => {
+         stream._reading = false
+         stream._emit('error', err)
+      })
+      pump()
+   }
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      if (event === 'data') _startReading(this)
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto.pipe = function (dest) {
+      this.on('data', chunk => dest.write?.(chunk))
+      this.once('end', () => dest.end?.())
+      this.once('error', err => dest.destroy?.(err))
+      return dest
+   }
+
+   proto.pause = function () {
+      this._paused = true
+      return this
+   }
+
+   proto.resume = function () {
+      this._paused = false
+      this._pump?.()
+      return this
+   }
+
+   proto.destroy = function (err) {
+      if (err) this._emit('error', err)
+      this._emit('close')
+      this.cancel(err).catch(() => { })
+      return this
+   }
+
+   proto.unpipe = function (dest) {
+      this._listeners = {}
+      return this
+   }
+}
+
+// Add Node.js-specific API to W3C WritableStream
+{
+   const proto = WritableStream.prototype
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto._getWriter = function () {
+      if (!this._writer) this._writer = this.getWriter()
+      return this._writer
+   }
+
+   proto.write = function (chunk, encoding, callback) {
+      if (typeof encoding === 'function') { callback = encoding; encoding = undefined }
+      const writer = this._getWriter()
+      writer.ready.then(() => writer.write(chunk)).then(
+         () => { this._emit('drain'); callback?.() },
+         err => { this._emit('error', err); callback?.(err) }
+      )
+      return true
+   }
+
+   proto.end = function (chunk, encoding, callback) {
+      if (typeof chunk === 'function') { callback = chunk; chunk = null }
+      else if (typeof encoding === 'function') { callback = encoding; encoding = null }
+      const writer = this._getWriter()
+      const finish = () => writer.close().then(
+         () => { this._emit('finish'); this._emit('close'); callback?.() },
+         err => { this._emit('error', err); callback?.(err) }
+      )
+      if (chunk != null) {
+         writer.ready.then(() => writer.write(chunk)).then(finish, finish)
+      } else {
+         finish()
+      }
+      return this
+   }
+
+   proto.destroy = function (err) {
+      const writer = this._getWriter()
+      if (err) {
+         writer.abort(err).catch(() => { })
+         this._emit('error', err)
+      } else {
+         writer.close().catch(() => { })
+      }
+      this._emit('close')
+      return this
+   }
+
+   proto.cork = function () { this._corked = (this._corked || 0) + 1 }
+   proto.uncork = function () { if (this._corked > 0) this._corked-- }
+
+   proto.setDefaultEncoding = function (encoding) {
+      this._defaultEncoding = encoding
+      return this
+   }
+}
+
+// Add Node.js-specific API to W3C TransformStream
+{
+   const proto = TransformStream.prototype
+
+   proto._emit = function (event, ...args) {
+      this._listeners?.[event]?.slice().forEach(fn => fn(...args))
+   }
+
+   proto.on = proto.addListener = function (event, fn) {
+      this._listeners ??= {}
+         ; (this._listeners[event] ??= []).push(fn)
+      if (event === 'data') this.readable.on('data', chunk => this._emit('data', chunk))
+      return this
+   }
+
+   proto.once = function (event, fn) {
+      const wrapped = (...args) => { this.off(event, wrapped); fn(...args) }
+      return this.on(event, wrapped)
+   }
+
+   proto.off = proto.removeListener = function (event, fn) {
+      const list = this._listeners?.[event]
+      if (list) { const i = list.indexOf(fn); if (i >= 0) list.splice(i, 1) }
+      return this
+   }
+
+   proto.write = function (chunk, encoding, callback) {
+      return this.writable.write(chunk, encoding, callback)
+   }
+
+   proto.end = function (chunk, encoding, callback) {
+      return this.writable.end(chunk, encoding, callback)
+   }
+
+   proto.pipe = function (dest) {
+      return this.readable.pipe(dest)
+   }
+
+   proto.pause = function () {
+      this.readable.pause()
+      return this
+   }
+
+   proto.resume = function () {
+      this.readable.resume()
+      return this
+   }
+
+   proto.destroy = function (err) {
+      this.readable.destroy(err)
+      this.writable.destroy(err)
+      return this
+   }
+}

package/esm/builder/build-target.js

@@ -30,9 +30,9 @@ export class BuildTarget {
             this.transaction = this.storage.edit();
         return this.transaction;
     }
-    store() {
+    async store() {
         if (this.transaction) {
-            this.transaction.accept();
+            await this.transaction.accept();
             this.transaction = null;
         }
     }
@@ -47,10 +47,10 @@ export class BuildTarget {
             publish: undefined,
             entries: undefined,
         };
-        if (descriptor.services) {
-            manifest.services = {};
-            for (const name in descriptor.services) {
-                manifest.services[name] = this.esmodules.add_resource_entry(descriptor.services[name], baseDir, library);
+        if (descriptor.apis) {
+            manifest.apis = {};
+            for (const name in descriptor.apis) {
+                manifest.apis[name] = this.esmodules.add_resource_entry(descriptor.apis[name], baseDir, library);
             }
         }
         if (descriptor.resources) {
@@ -90,7 +90,7 @@ export class BuildTarget {
             });
         }
         else {
-            this.store();
+            await this.store();
         }
     }
 }

package/esm/builder/helpers/emit-esmodules.js

@@ -21,7 +21,7 @@ function getEsbuildLogLevel(mode) {
             return "silent";
     }
 }
-export async function create_esbuild_context(task, devmode) {
+async function create_esbuild_context(task, devmode, onReady) {
     const ws = task.target.workspace;
     // Define modules mapping - using @jspm/core polyfills (same as Vite)
     const jspmPolyfills = Path.resolve(PackageRootDir, "node_modules/@jspm/core/nodelibs/browser");
@@ -111,7 +111,7 @@ export async function create_esbuild_context(task, devmode) {
             ESModuleResolverPlugin(modules_mapping, tsconfig),
             ...task.plugins,
             StyleSheetPlugin(task),
-            StoragePlugin(task),
+            StoragePlugin(task, onReady),
         ],
         loader: {
             '.jpg': 'file',
@@ -255,7 +255,7 @@ function hasTailwindConfig(workspacePath) {
     catch { }
     return false;
 }
-export function StoragePlugin(task) {
+export function StoragePlugin(task, onReady) {
     return {
         name: "dipatch-files",
         setup: (build) => {
@@ -287,10 +287,14 @@ export function StoragePlugin(task) {
                             throw new Error(`Invalid output file: ${file.path}`);
                         }
                     }
-                    task.target.store();
+                    await task.target.store();
                     const storeTime = (Date.now() - storeStart) / 1000;
                     const buildTime = (Date.now() - buildStartTime) / 1000;
-                    task.log.info(`Build ES modules in ${result.outputFiles.length} file(s) (compile: ${buildTime.toFixed(2)}s, store: ${storeTime.toFixed(2)}s)`);
+                    task.log.info(`Store ES graph in ${result.outputFiles.length} file(s) (compile: ${buildTime.toFixed(2)}s, store: ${storeTime.toFixed(2)}s)`);
+                }
+                if (onReady) {
+                    onReady();
+                    onReady = null;
                 }
                 return null;
             });
@@ -602,11 +606,14 @@ export class ESModulesTask extends BuildTask {
             await prev_ctx.dispose();
         }
         const { target } = this;
-        this.context = await create_esbuild_context(this, target.devmode);
         if (target.watch) {
-            await this.context.watch();
+            return new Promise(async (resolve, reject) => {
+                this.context = await create_esbuild_context(this, target.devmode, resolve);
+                await this.context.watch();
+            });
         }
         else {
+            this.context = await create_esbuild_context(this, target.devmode);
             await this.context.rebuild();
             await this.context.dispose();
         }

package/esm/model/component.js

@@ -14,7 +14,7 @@ export function makeComponentPublication(manif) {
         type: manif.type,
         icon: manif.icon,
         title: manif.title || manif.name || manif.$id,
-        services: manif.services ? Object.keys(manif.services) : [],
+        services: manif.apis ? Object.keys(manif.apis) : [],
         description: manif.description || "",
         keywords: manif.keywords,
         tags: manif.tags,

package/esm/model/helpers/discover-workspace.js

@@ -49,6 +49,10 @@ async function discover_component(lib, fpath) {
             const err = checkComponentManifest(desc, fpath);
             if (err)
                 throw err;
+            if (!desc.apis && desc["services"]) {
+                desc.apis = desc["services"]; // Migrate renaming 'services' -> 'apis'
+                lib.log.warn(`Component '${desc.$id}' manifest shall rename 'services' -> 'apis'`);
+            }
             bundle.components.set(fpath, desc);
             lib.log.info(`+ 🧩 component: ${desc.$id} ${desc.type ? `(${desc.type})` : ""}`);
             return true;

package/esm/model/storage.js

@@ -50,24 +50,22 @@ export class StorageTransaction {
         const hash = createContentCID(contentData);
         this.pending.set(fpath, { data: contentData, hash });
     }
-    accept() {
+    async accept() {
         const { root, scratch, baseDir } = this;
-        directory.make(baseDir);
+        await Fsp.mkdir(baseDir, { recursive: true });
         const changes = { added: [], updated: [], changed: false };
+        const writes = [];
         for (const [fpath, { data, hash }] of this.pending) {
             const prev = root.cache.get(fpath);
             if (prev !== hash) {
                 ;
                 (prev ? changes.updated : changes.added).push(Path.basename(fpath));
-                directory.make(Path.dirname(fpath));
-                Fs.writeFileSync(fpath, data);
+                writes.push(Fsp.mkdir(Path.dirname(fpath), { recursive: true }).then(() => Fsp.writeFile(fpath, data)));
             }
             root.cache.set(fpath, hash);
         }
+        await Promise.all(writes);
         this.pending.clear();
-        /*
-              const removed = root.cache.size - newCache.size + changes.added.length
-              changes.changed = removed !== 0 || changes.added.length !== 0 || changes.updated.length !== 0*/
         if (changes.updated.length > 0 || changes.added.length > 0) {
             root.on_changes.sendEventsToAll("change", changes);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.15",
+   "version": "1.1.17",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"

package/schemas/component.schema.json

@@ -167,7 +167,7 @@
             "additionalProperties": true
          }
       },
-      "services": {
+      "apis": {
          "type": "object",
          "description": "Resources providing specific services interfaces.",
          "additionalProperties": {