rip-lang 3.15.1 → 3.15.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.15.1",
+  "version": "3.15.3",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -24,6 +24,7 @@
     "bin/",
     "src/",
     "docs/",
+    "scripts/postinstall.js",
     "scripts/serve.js",
     "rip-loader.js",
     "README.md",
@@ -36,7 +37,7 @@
     "gallery": "bun scripts/gallery.js",
     "bundle:demo": "bun scripts/bundle-app.js docs/demo -o docs/example/index.json -t 'Rip App Demo'",
     "parser": "bun src/grammar/solar.rip -o src/parser.js src/grammar/grammar.rip",
-    "postinstall": "bun scripts/link-local.js --quiet && bun scripts/link-check.js --quiet",
+    "postinstall": "node scripts/postinstall.js --quiet",
     "link-local": "bun scripts/link-local.js",
     "link-global": "bun scripts/link-global.js",
     "link-check": "bun scripts/link-check.js",

package/scripts/postinstall.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// scripts/postinstall.js — workspace-only postinstall hook.
+//
+// `link-local.js` and `link-check.js` rewrite `node_modules/.bun/` and
+// `node_modules/rip-lang/` to point at the workspace's source tree.
+// That's exactly what we want during dev, but it's meaningless — and
+// would error — for consumers running `npm install rip-lang` from
+// outside this repo (no `packages/` sibling, possibly no `bun` binary).
+//
+// This dispatcher checks for the workspace markers first and exits 0
+// otherwise. Uses Node only (every npm install has Node; not every
+// consumer has Bun). Tolerates missing files / non-zero subprocess
+// exits — postinstall is best-effort, never fatal for consumers.
+
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+if (!existsSync('packages') || !existsSync('scripts/link-local.js')) process.exit(0);
+
+const args = process.argv.slice(2);
+const run = (script) => {
+  const r = spawnSync('bun', ['scripts/' + script, ...args], { stdio: 'inherit' });
+  return r.status ?? 0;
+};
+
+run('link-local.js');
+run('link-check.js');

package/src/browser.js

@@ -222,14 +222,22 @@ async function processRipScripts() {
       }
       expanded.push(...individual);
 
-      // Source maps are ON by default — `data-debug="false"` opts out.
-      // Individually compile each source with its own source map; we'll
-      // sequentially eval them per-component so each has a self-consistent
-      // map (DevTools only honours the last sourceMappingURL inside an
-      // eval, so concatenating maps doesn't work).
+      // Bundle / multi-source path. Components defined in one .rip file
+      // need to be visible to siblings (e.g. `WidgetGallery` referencing
+      // sibling widgets like `Toast`, `Dialog`, `Menu`). To make that
+      // work we concatenate every compiled chunk into ONE async-IIFE and
+      // eval it as a single closure — declarations made by one source
+      // are visible to all subsequent sources via lexical scope.
+      //
+      // Trade-off: source maps don't work in concat mode (each
+      // `compileToJS` call emits its own map; concatenation would need a
+      // map merger we don't have). Source maps still work for:
+      //   - the data-router path (app.launch component compile, Phase 2)
+      //   - the single-inline-script path (one source = one map)
+      // The bundle no-router path is mostly used by component libraries
+      // (packages/ui itself) where step-debugging is less critical.
+      // Inline source maps are skipped here unconditionally.
       const debug = runtimeTag?.getAttribute('data-debug') !== 'false';
-      // Update the global flag so app.launch()'s compile path (in app.rip)
-      // sees the same setting as our local `debug` variable.
       if (globalThis.__ripDebug) globalThis.__ripDebug.enabled = debug;
       const baseOpts = { skipRuntimes: true, skipExports: true, skipImports: true };
       const compiled = [];
@@ -237,11 +245,8 @@ async function processRipScripts() {
       for (const s of expanded) {
         if (!s.code) continue;
         const ripName = s.url || `inline-${++inlineCounter}.rip`;
-        const opts = debug
-          ? { ...baseOpts, sourceMap: 'inline', filename: ripName }
-          : baseOpts;
         try {
-          const js = compileToJS(s.code, opts);
+          const js = compileToJS(s.code, baseOpts);
           compiled.push({ js, url: ripName });
         } catch (e) {
           console.error(_formatError(e, { source: s.code, file: ripName, color: false }));
@@ -269,35 +274,26 @@ async function processRipScripts() {
         }
       }
 
-      // Execute compiled code per-component so each has its own valid
-      // source map (DevTools only honours the last `sourceMappingURL`
-      // pragma inside one evaluated chunk, so concatenating multiple
-      // source-mapped chunks would lose all but the last). Components
-      // share scope via globalThis attachment — typical Rip definitions
-      // (`Foo = component`, `Bar = ...`) compile to globalThis-attached
-      // bindings under `skipExports/skipImports`, which survive between
-      // the per-component evals.
+      // Concatenate all compiled chunks into one async IIFE so component
+      // declarations made in earlier chunks are visible (via lexical
+      // scope) to later chunks AND to the final mount step. Without
+      // this, each chunk's `let Foo = class ...` dies when its IIFE
+      // returns and `WidgetGallery` (defined in one chunk) can't see
+      // `Toast` (defined in another).
       if (compiled.length > 0) {
-        let anyError = false;
-        for (const c of compiled) {
-          try {
-            await (0, eval)(debug ? wrapForEval(c.js, c.url) : `(async()=>{\n${c.js}\n})()`);
-          } catch (e) {
-            anyError = true;
-            if (e instanceof SyntaxError) console.error(`Rip syntax error in ${c.url}: ${e.message}`);
-            else console.error(`Rip runtime error in ${c.url}:`, e);
-          }
-        }
-
-        // Final mount step — runs after all components are defined.
         const mount = runtimeTag?.getAttribute('data-mount');
-        if (mount) {
-          const target = runtimeTag.getAttribute('data-target') || 'body';
-          try { await (0, eval)(`(async()=>{ ${mount}.mount(${JSON.stringify(target)}); })()`); }
-          catch (e) { console.error(`Rip mount error (${mount}):`, e); }
+        const target = runtimeTag?.getAttribute('data-target') || 'body';
+        const mountSnippet = mount ? `\n${mount}.mount(${JSON.stringify(target)});\n` : '';
+        const merged = compiled.map(c => c.js).join('\n;\n');
+        let ok = true;
+        try {
+          await (0, eval)(`(async()=>{\n${merged}${mountSnippet}\n})()`);
+        } catch (e) {
+          ok = false;
+          if (e instanceof SyntaxError) console.error(`Rip syntax error: ${e.message}`);
+          else console.error('Rip runtime error:', e);
         }
-
-        if (!anyError) document.body.classList.add('ready');
+        if (ok) document.body.classList.add('ready');
       }
     }
   }