rip-lang 3.15.4 → 3.16.1

package/src/browser.js

@@ -10,7 +10,7 @@ import './schema/loader-browser.js';
 export { Lexer } from './lexer.js';
 export { parser } from './parser.js';
 export { CodeEmitter, Compiler, compile, compileToJS, formatSExpr, getStdlibCode, getReactiveRuntime, getComponentRuntime, RipError, formatError, formatErrorHTML } from './compiler.js';
-import { mergeChunksWithInlineMap } from './sourcemap-merge.js';
+import { mergeChunksWithInlineMap } from './sourcemaps.js';
 import { getStdlibCode, formatError as _formatError } from './compiler.js';
 
 // Version info (replaced during build)
@@ -48,6 +48,40 @@ const dedent = s => {
 const sanitizeSourceURL = (url) =>
   String(url).replace(/[\r\n]/g, '').replace(/\s+$/g, '');
 
+// Rewrite `import { … } from '@rip-lang/<pkg>'` into a `globalThis`
+// destructure. The browser bundle copies every function export from
+// `@rip-lang/app` (and friends) onto `globalThis` at startup (see
+// `_entry.js` in scripts/build.js), so consumers can import them by name
+// in source while the runtime form is a plain destructure. Named imports
+// only — default / namespace forms warn and pass through.
+function rewriteRipPkgImports(js) {
+  const re = /^(\s*)import\s+([^'"]+?)\s+from\s+['"](@rip-lang\/[^'"]+)['"];?\s*$/gm;
+  return js.replace(re, (full, indent, clause, spec) => {
+    const trimmed = clause.trim();
+    if (trimmed.startsWith('type ')) return `${indent}// type-only import erased: ${spec}`;
+    const open = trimmed.indexOf('{');
+    const close = trimmed.lastIndexOf('}');
+    if (open < 0 || close <= open) {
+      console.warn(`[Rip] Skipping non-named import from ${spec}; only \`import { … } from '@rip-lang/*'\` is supported in browser bundles.`);
+      return full;
+    }
+    const inside = trimmed.slice(open + 1, close);
+    const parts = [];
+    for (let raw of inside.split(',')) {
+      let name = raw.trim().replace(/^type\s+/, '');
+      if (!name) continue;
+      if (/\s+as\s+/.test(name)) {
+        const [orig, alias] = name.split(/\s+as\s+/).map(s => s.trim());
+        parts.push(`${orig}: ${alias}`);
+      } else {
+        parts.push(name);
+      }
+    }
+    if (parts.length === 0) return `${indent}// import erased: ${spec}`;
+    return `${indent}const { ${parts.join(', ')} } = globalThis;`;
+  });
+}
+
 // Insert `//# sourceURL=<name>` BEFORE the existing `//# sourceMappingURL=...`
 // comment (or append at end if none). NEVER prepend — that would shift every
 // generated-line mapping by 1 line, breaking line-only source maps.
@@ -124,14 +158,20 @@ if (typeof globalThis !== 'undefined') {
 // All other URLs are fetched as JSON bundles containing multiple files.
 async function processRipScripts() {
   const sources = [];
+  let lastBundle;
 
   // Step 1: Collect data-src URLs from the runtime script tag
+  // When data-src is omitted, default to '/app' (auto-scanned bundle from
+  // serve middleware). The default is silent on failure — only explicit
+  // data-src URLs warn — so static / file:// pages aren't noisy.
   const runtimeTag = document.querySelector('script[src$="rip.min.js"], script[src$="rip.js"]');
   const dataSrc = runtimeTag?.getAttribute('data-src');
-  if (dataSrc) {
+  if (dataSrc !== null && dataSrc !== undefined) {
     for (const url of dataSrc.trim().split(/\s+/)) {
       if (url) sources.push({ url });
     }
+  } else if (runtimeTag && /^https?:$/.test(location.protocol)) {
+    sources.push({ url: '/app', optional: true });
   }
 
   // Step 2: Collect all <script type="text/rip"> tags (inline and external)
@@ -157,8 +197,11 @@ async function processRipScripts() {
         s.bundle = bundle;
       }
     }));
-    for (const r of results) {
-      if (r.status === 'rejected') console.warn('Rip: fetch failed:', r.reason.message);
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      if (r.status === 'rejected' && !sources[i].optional) {
+        console.warn('Rip: fetch failed:', r.reason.message);
+      }
     }
 
     // Separate bundles from individual sources
@@ -170,7 +213,21 @@ async function processRipScripts() {
     }
 
     const routerAttr = runtimeTag?.getAttribute('data-router');
-    const hasRouter = routerAttr != null;
+    lastBundle = bundles[bundles.length - 1];
+    // data-router auto-infers from bundle.data.router (set by the server when
+    // the app has a routes/ directory). Explicit attribute always wins:
+    //   data-router            → enabled
+    //   data-router="hash"     → hash routing
+    //   data-router="false"    → explicitly disabled
+    //   (omitted)              → fall back to bundle.data.router
+    let hasRouter, hashRouter;
+    if (routerAttr != null) {
+      hasRouter = routerAttr !== 'false';
+      hashRouter = routerAttr === 'hash';
+    } else {
+      hasRouter = !!(lastBundle?.data?.router);
+      hashRouter = false;
+    }
 
     // Step 3b: If data-router is present and we have a bundle, use launch()
     // for full routing support. Otherwise compile everything upfront.
@@ -191,7 +248,7 @@ async function processRipScripts() {
           ? { ...baseOpts, sourceMap: 'inline', filename: ripName }
           : baseOpts;
         let js;
-        try { js = compileToJS(s.code, opts); }
+        try { js = rewriteRipPkgImports(compileToJS(s.code, opts)); }
         catch (e) { console.error(_formatError(e, { source: s.code, file: ripName, color: false })); continue; }
         try { await (0, eval)(debug ? wrapForEval(js, ripName) : `(async()=>{\n${js}\n})()`); }
         catch (e) { console.error(`Rip runtime error in ${ripName}:`, e); }
@@ -200,17 +257,17 @@ async function processRipScripts() {
       // Launch with the last bundle (app bundle) — handles router, renderer, stash
       const app = importRip.modules?.['app.rip'];
       if (app?.launch) {
-        const appBundle = bundles[bundles.length - 1];
         const persistAttr = runtimeTag.getAttribute('data-persist');
-        const launchOpts = { bundle: appBundle, hash: routerAttr === 'hash' };
+        const launchOpts = { bundle: lastBundle, hash: hashRouter };
         if (persistAttr != null) launchOpts.persist = persistAttr === 'local' ? 'local' : true;
-        await app.launch('', launchOpts);
+        await app.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 || {})) {
+        const mods = b.modules || b.components || {};
+        for (const [name, code] of Object.entries(mods)) {
           expanded.push({ code, url: name });
         }
         if (b.data) {
@@ -223,6 +280,22 @@ async function processRipScripts() {
       }
       expanded.push(...individual);
 
+      // Expose the components-source store on window.__RIP__ so source-text
+      // access (e.g. view-source UIs) works the same on the no-router path
+      // as it does after launch(). Mirrors what launch() sets up — minus
+      // app/router/renderer, since those don't exist on this path.
+      if (bundles.length > 0 && typeof globalThis.createComponents === 'function') {
+        const sourceStore = globalThis.createComponents();
+        for (const b of bundles) {
+          const mods = b.modules || b.components;
+          if (mods) sourceStore.load(mods);
+        }
+        if (typeof window !== 'undefined') {
+          if (!window.__RIP__) window.__RIP__ = {};
+          window.__RIP__.components = sourceStore;
+        }
+      }
+
       // Bundle / multi-source path. Components defined in one .rip file
       // need to be visible to siblings (e.g. `WidgetGallery` referencing
       // `Toast`, `Dialog`, `Menu`). To make that work we concatenate
@@ -248,7 +321,7 @@ async function processRipScripts() {
           ? { ...baseOpts, sourceMap: 'inline', filename: ripName }
           : baseOpts;
         try {
-          const js = compileToJS(s.code, opts);
+          const js = rewriteRipPkgImports(compileToJS(s.code, opts));
           compiled.push({ js, url: ripName });
         } catch (e) {
           console.error(_formatError(e, { source: s.code, file: ripName, color: false }));
@@ -257,7 +330,7 @@ async function processRipScripts() {
 
       // Create app stash
       if (!globalThis.__ripApp && runtimeTag) {
-        const stashFn = globalThis.stash;
+        const stashFn = globalThis.createStash;
         if (stashFn) {
           let initial = {};
           const stateAttr = runtimeTag.getAttribute('data-state');
@@ -315,10 +388,19 @@ async function processRipScripts() {
 
   // Step 6: data-reload enables SSE hot-reload from dev server
   // Skip if launch() was called — it connects its own SSE watch.
+  // Auto-infers from bundle.data.watch (set by the server when --watch is on).
+  // Explicit attribute always wins:
+  //   data-reload          → enabled
+  //   data-reload="false"  → explicitly disabled
+  //   (omitted)            → fall back to bundle.data.watch
   // Uses exponential backoff: 1s → 2s → 4s → … → 30s (then 30s forever).
   // The retry delay only affects reconnection to a DOWN server — once connected,
   // the server pushes reload notifications instantly regardless of this value.
-  if (runtimeTag?.hasAttribute('data-reload') && !globalThis.__ripLaunched) {
+  const reloadAttr = runtimeTag?.getAttribute('data-reload');
+  const shouldReload = reloadAttr != null
+    ? reloadAttr !== 'false'
+    : !!(lastBundle?.data?.watch);
+  if (shouldReload && !globalThis.__ripLaunched) {
     let ready = false;
     let retryDelay = 1000;
     const maxDelay = 30000;
@@ -373,7 +455,7 @@ export async function importRip(url) {
     if (!r.ok) throw new Error(`importRip: ${url} (${r.status})`);
     return r.text();
   });
-  const js = compileToJS(source);
+  const js = rewriteRipPkgImports(compileToJS(source));
   const header = `// ${url}\n`;
   const blob = new Blob([header + js], { type: 'application/javascript' });
   const blobUrl = URL.createObjectURL(blob);