rip-lang 3.13.83 → 3.13.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.83",
+  "version": "3.13.85",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/browser.js

@@ -26,9 +26,11 @@ const dedent = s => {
   return s.replace(RegExp(`^[ \t]{${i}}`, 'gm'), '').trim();
 }
 
-// Browser runtime: collect all <script type="text/rip"> sources (inline + src)
-// plus any data-src URLs on the runtime tag, compile them all with shared-scope
-// options, and execute as one async IIFE. Then handle data-launch for server mode.
+// Browser runtime: collect all sources (inline scripts, data-src files, bundles),
+// compile them in a shared scope, and execute as one async IIFE.
+//
+// data-src URLs ending in .rip are fetched as individual source files.
+// All other URLs are fetched as JSON bundles containing multiple files.
 async function processRipScripts() {
   const sources = [];
 
@@ -51,99 +53,141 @@ async function processRipScripts() {
     }
   }
 
-  // Step 3: Fetch externals, compile all, execute in shared scope
+  // Step 3: Fetch externals — .rip URLs as source text, others as JSON bundles
   if (sources.length > 0) {
-    await Promise.all(sources.map(async (s) => {
+    const results = await Promise.allSettled(sources.map(async (s) => {
       if (!s.url) return;
-      try {
-        const res = await fetch(s.url);
-        if (!res.ok) {
-          console.error(`Rip: failed to fetch ${s.url} (${res.status})`);
-          return;
-        }
+      const res = await fetch(s.url);
+      if (!res.ok) throw new Error(`${s.url} (${res.status})`);
+      if (s.url.endsWith('.rip')) {
         s.code = await res.text();
-      } catch (e) {
-        console.error(`Rip: failed to fetch ${s.url}:`, e.message);
+      } else {
+        const bundle = await res.json();
+        s.bundle = bundle;
       }
     }));
+    for (const r of results) {
+      if (r.status === 'rejected') console.warn('Rip: fetch failed:', r.reason.message);
+    }
 
-    const opts = { skipRuntimes: true, skipExports: true };
-    const compiled = [];
+    // Separate bundles from individual sources
+    const bundles = [];
+    const individual = [];
     for (const s of sources) {
-      if (!s.code) continue;
-      try {
-        const js = compileToJS(s.code, opts);
-        compiled.push({ js, url: s.url || 'inline' });
-      } catch (e) {
-        console.error(`Rip compile error in ${s.url || 'inline'}:`, e.message);
-      }
+      if (s.bundle) bundles.push(s.bundle);
+      else if (s.code) individual.push(s);
     }
 
-    // Step 3b: Create app stash for data-src mode (skip if data-launch will handle it)
-    if (!globalThis.__ripApp && runtimeTag && !document.querySelector('script[data-launch]')) {
-      const stashFn = globalThis.stash;
-      if (stashFn) {
-        let initial = {};
-        const stateAttr = runtimeTag.getAttribute('data-state');
-        if (stateAttr) {
-          try { initial = JSON.parse(stateAttr); }
-          catch (e) { console.error('Rip: invalid data-state JSON:', e.message); }
+    const routerAttr = runtimeTag?.getAttribute('data-router');
+    const hasRouter = routerAttr != null;
+
+    // Step 3b: If data-router is present and we have a bundle, use launch()
+    // for full routing support. Otherwise compile everything upfront.
+    if (hasRouter && bundles.length > 0) {
+      // Compile non-bundle sources (inline scripts, individual .rip files)
+      const opts = { skipRuntimes: true, skipExports: true };
+      if (individual.length > 0) {
+        let js = '';
+        for (const s of individual) {
+          try { js += compileToJS(s.code, opts) + '\n'; }
+          catch (e) { console.error(`Rip compile error in ${s.url || 'inline'}:`, e.message); }
+        }
+        if (js) {
+          try { await (0, eval)(`(async()=>{\n${js}\n})()`); }
+          catch (e) { console.error('Rip runtime error:', e); }
         }
-        const app = stashFn({ data: initial });
-        globalThis.__ripApp = app;
-        if (typeof window !== 'undefined') window.app = app;
+      }
 
+      // Launch with the last bundle (app bundle) — handles router, renderer, stash
+      const ui = importRip.modules?.['ui.rip'];
+      if (ui?.launch) {
+        const appBundle = bundles[bundles.length - 1];
         const persistAttr = runtimeTag.getAttribute('data-persist');
-        if (persistAttr != null && globalThis.persistStash) {
-          globalThis.persistStash(app, { local: persistAttr === 'local' });
+        const launchOpts = { bundle: appBundle, hash: routerAttr === 'hash' };
+        if (persistAttr != null) launchOpts.persist = persistAttr === 'local' ? 'local' : true;
+        await ui.launch('', launchOpts);
+      }
+    } else {
+      // No routing — expand bundles into individual sources, compile everything
+      const expanded = [];
+      for (const b of bundles) {
+        for (const [name, code] of Object.entries(b.components || {})) {
+          expanded.push({ code, url: name });
+        }
+        if (b.data) {
+          const stateAttr = runtimeTag?.getAttribute('data-state');
+          let initial = {};
+          if (stateAttr) { try { initial = JSON.parse(stateAttr); } catch {} }
+          Object.assign(initial, b.data);
+          runtimeTag?.setAttribute('data-state', JSON.stringify(initial));
         }
       }
-    }
-
-    if (compiled.length > 0) {
-      let js = compiled.map(c => c.js).join('\n');
+      expanded.push(...individual);
 
-      // Step 4: Append data-mount call inside the shared IIFE
-      const mount = runtimeTag?.getAttribute('data-mount');
-      if (mount) {
-        const target = runtimeTag.getAttribute('data-target') || 'body';
-        js += `\n${mount}.mount(${JSON.stringify(target)});`;
+      const opts = { skipRuntimes: true, skipExports: true };
+      const compiled = [];
+      for (const s of expanded) {
+        if (!s.code) continue;
+        try {
+          const js = compileToJS(s.code, opts);
+          compiled.push({ js, url: s.url || 'inline' });
+        } catch (e) {
+          console.error(`Rip compile error in ${s.url || 'inline'}:`, e.message);
+        }
       }
 
-      try {
-        await (0, eval)(`(async()=>{\n${js}\n})()`);
-        document.body.classList.add('ready');
-      } catch (e) {
-        if (e instanceof SyntaxError) {
-          console.error(`Rip syntax error in combined output: ${e.message}`);
-          for (const c of compiled) {
-            try { new Function(`(async()=>{\n${c.js}\n})()`); }
-            catch (e2) { console.error(`  → source: ${c.url}`, e2.message); }
+      // Create app stash
+      if (!globalThis.__ripApp && runtimeTag) {
+        const stashFn = globalThis.stash;
+        if (stashFn) {
+          let initial = {};
+          const stateAttr = runtimeTag.getAttribute('data-state');
+          if (stateAttr) {
+            try { initial = JSON.parse(stateAttr); }
+            catch (e) { console.error('Rip: invalid data-state JSON:', e.message); }
+          }
+          const app = stashFn({ data: initial });
+          globalThis.__ripApp = app;
+          if (typeof window !== 'undefined') window.app = app;
+
+          const persistAttr = runtimeTag.getAttribute('data-persist');
+          if (persistAttr != null && globalThis.persistStash) {
+            globalThis.persistStash(app, { local: persistAttr === 'local' });
           }
-        } else {
-          console.error('Rip runtime error:', e);
         }
       }
-    }
-  }
 
-  // Step 5: data-launch triggers launch() for server mode
-  const cfg = document.querySelector('script[data-launch]');
-  if (cfg && !globalThis.__ripLaunched) {
-    const ui = importRip.modules?.['ui.rip'];
-    if (ui?.launch) {
-      const url = cfg.getAttribute('data-launch') || '';
-      const hash = cfg.getAttribute('data-hash');
-      const persist = cfg.getAttribute('data-persist');
-      const opts = { hash: hash !== 'false' };
-      if (url) opts.bundleUrl = url;
-      if (persist != null) opts.persist = persist === 'local' ? 'local' : true;
-      await ui.launch('', opts);
+      // Execute all compiled code in shared scope
+      if (compiled.length > 0) {
+        let js = compiled.map(c => c.js).join('\n');
+
+        const mount = runtimeTag?.getAttribute('data-mount');
+        if (mount) {
+          const target = runtimeTag.getAttribute('data-target') || 'body';
+          js += `\n${mount}.mount(${JSON.stringify(target)});`;
+        }
+
+        try {
+          await (0, eval)(`(async()=>{\n${js}\n})()`);
+          document.body.classList.add('ready');
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            console.error(`Rip syntax error in combined output: ${e.message}`);
+            for (const c of compiled) {
+              try { new Function(`(async()=>{\n${c.js}\n})()`); }
+              catch (e2) { console.error(`  → source: ${c.url}`, e2.message); }
+            }
+          } else {
+            console.error('Rip runtime error:', e);
+          }
+        }
+      }
     }
   }
 
   // Step 6: data-reload enables SSE hot-reload from dev server
-  if (runtimeTag?.hasAttribute('data-reload')) {
+  // Skip if launch() was called — it connects its own SSE watch.
+  if (runtimeTag?.hasAttribute('data-reload') && !globalThis.__ripLaunched) {
     let ready = false;
     const es = new EventSource('/watch');
     es.addEventListener('connected', () => {
@@ -233,9 +277,8 @@ if (typeof globalThis !== 'undefined') {
   globalThis.__ripExports = { compile, compileToJS, formatSExpr, getStdlibCode, VERSION, BUILD_DATE, getReactiveRuntime, getComponentRuntime };
 }
 
-// Auto-process <script type="text/rip"> blocks and handle data-launch.
-// Deferred via queueMicrotask so bundled entry code (e.g. rip.min.js registering
-// importRip.modules) runs before script processing begins.
+// Auto-process <script type="text/rip"> blocks and data-src sources.
+// Deferred via queueMicrotask so bundled entry code runs before script processing.
 if (typeof document !== 'undefined') {
   globalThis.__ripScriptsReady = new Promise(resolve => {
     const run = () => processRipScripts().then(resolve);