@omriashke/dynamico-core 0.1.9 → 0.1.12

package/src/relativeRequires.ts

@@ -1,3 +1,5 @@
+import type { Diagnostic } from "./types.js";
+
 /** Map a relative require specifier to the flat registry component name (basename). */
 export function resolveRelativeComponentName(specifier: string): string | null {
   if (!specifier.startsWith("./") && !specifier.startsWith("../") && !specifier.startsWith("/")) {
@@ -37,3 +39,49 @@ export function collectRelativeComponentDeps(code: string, componentName?: strin
   }
   return [...deps];
 }
+
+export interface RelativeImportValidation {
+  ok: boolean;
+  message?: string;
+  diagnostics?: Diagnostic[];
+}
+
+/**
+ * Reject relative imports that resolve to registry names not in the manifest.
+ * Local utility files should be bundled at compile time; any remaining relative
+ * require() must target another registered component.
+ */
+export function validateRelativeImports(
+  code: string,
+  registered: ReadonlySet<string>,
+  componentName?: string,
+): RelativeImportValidation {
+  const unresolved: string[] = [];
+  for (const specifier of extractRelativeRequires(code)) {
+    const base = resolveRelativeComponentName(specifier);
+    if (!base) continue;
+    if (base === componentName) continue;
+    if (!registered.has(base)) unresolved.push(specifier);
+  }
+  if (unresolved.length === 0) return { ok: true };
+
+  const lines = unresolved.map(
+    (spec) =>
+      `  ${spec} → registry component '${resolveRelativeComponentName(spec)}' is not registered`,
+  );
+  const message =
+    `relative import(s) must target a registered component or a local file bundled into this module:\n` +
+    `${lines.join("\n")}\n` +
+    `Push the dependency as its own component, move helpers into this file, ` +
+    `import from host scope (e.g. @newscast/utils-app-ui), or colocate as ./sibling.ts (auto-bundled).`;
+
+  return {
+    ok: false,
+    message,
+    diagnostics: unresolved.map((spec) => ({
+      severity: "error" as const,
+      message: `unregistered relative import '${spec}'`,
+      code: "RELATIVE_IMPORT",
+    })),
+  };
+}

package/src/sources/remote.ts

@@ -14,22 +14,28 @@ export interface RemoteSourceOptions {
   /**
    * Headers to send on every request. Called on each HTTP fetch and on each
    * WebSocket reconnect, so the function can return a freshly-rotated token.
-   *
-   * - HTTP: merged into the `Authorization: ...` / `x-api-key: ...` request headers.
-   * - WebSocket: passed as `new WebSocket(url, undefined, { headers })`. This
-   *   works on React Native (which extends the standard constructor); browsers
-   *   silently ignore it because the spec doesn't allow custom WS handshake
-   *   headers. For browsers behind authenticated reverse proxies, use a
-   *   query-string token in `wsUrl` or front the registry with cookie auth.
    */
   headers?: () => Record<string, string>;
+  /**
+   * Enable WebSocket live-reload. When the server pushes a module update the
+   * client re-evaluates it and re-renders the component.
+   *
+   * Same-version pushes (e.g. on reconnect the server replays the current
+   * module) are deduplicated in the registry and are no-ops — no re-eval, no
+   * new function identity, no remount. Only a genuinely new version triggers
+   * a re-render.
+   *
+   * @default true
+   */
+  webSocket?: boolean;
 }
 
 /**
  * Talks to @omriashke/dynamico-registry (or any compatible server).
  *
  *   GET  {url}/component/:name      -> CompiledModule (initial fetch)
- *   WS   {wsUrl}/subscribe          -> stream of CompiledModule updates
+ *   WS   {wsUrl}/subscribe          -> filtered push stream; client sends
+ *                                     `{ op: "watch", names: [...] }`
  */
 export function createRemoteSource(options: RemoteSourceOptions): Source {
   const fetchImpl: typeof fetch =
@@ -52,18 +58,38 @@ export function createRemoteSource(options: RemoteSourceOptions): Source {
     options.wsUrl ?? httpUrl.replace(/^http/, "ws") + "/subscribe";
 
   const listeners = new Set<(u: SourceUpdate) => void>();
+  const watchedNames = new Set<string>();
+  const watchRefCounts = new Map<string, number>();
   let socket: WebSocket | null = null;
   let disposed = false;
+  let pendingWatchSync = false;
   const reconnectMs = options.reconnectMs ?? 1000;
+  const useWebSocket = options.webSocket !== false;
+  const WS_OPEN = (WSCtor as unknown as { OPEN?: number }).OPEN ?? 1;
+  const WS_CONNECTING = (WSCtor as unknown as { CONNECTING?: number }).CONNECTING ?? 0;
+
+  function pushWatchSet(): void {
+    if (!useWebSocket || watchedNames.size === 0) return;
+    if (!socket || socket.readyState !== WS_OPEN) {
+      pendingWatchSync = true;
+      connect();
+      return;
+    }
+    pendingWatchSync = false;
+    try {
+      socket.send(JSON.stringify({ op: "watch", names: [...watchedNames] }));
+    } catch {
+      /* ignore */
+    }
+  }
 
   function connect(): void {
-    if (disposed) return;
+    if (disposed || !useWebSocket || watchedNames.size === 0) return;
+    if (socket && (socket.readyState === WS_OPEN || socket.readyState === WS_CONNECTING)) {
+      return;
+    }
     try {
       const hdrs = options.headers?.();
-      // RN's WebSocket constructor accepts a third {headers} arg that lets us
-      // attach Bearer / x-api-key tokens to the upgrade request. The standard
-      // browser WebSocket ignores extra constructor args, so this is a no-op
-      // there (use cookies / a query-string token instead).
       socket = hdrs
         ? new (WSCtor as unknown as new (
             url: string,
@@ -71,10 +97,13 @@ export function createRemoteSource(options: RemoteSourceOptions): Source {
             options?: { headers?: Record<string, string> },
           ) => WebSocket)(wsUrl, undefined, { headers: hdrs })
         : new WSCtor(wsUrl);
-    } catch (err) {
+    } catch {
       scheduleReconnect();
       return;
     }
+    socket.onopen = () => {
+      if (pendingWatchSync || watchedNames.size > 0) pushWatchSet();
+    };
     socket.onmessage = (ev: MessageEvent) => {
       try {
         const data =
@@ -103,11 +132,40 @@ export function createRemoteSource(options: RemoteSourceOptions): Source {
   }
 
   function scheduleReconnect(): void {
-    if (disposed) return;
+    if (disposed || !useWebSocket || watchedNames.size === 0) return;
     setTimeout(connect, reconnectMs);
   }
 
-  connect();
+  function watch(name: string): () => void {
+    if (!useWebSocket) return () => undefined;
+    const next = (watchRefCounts.get(name) ?? 0) + 1;
+    watchRefCounts.set(name, next);
+    if (next === 1) {
+      watchedNames.add(name);
+      pushWatchSet();
+    }
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const count = (watchRefCounts.get(name) ?? 1) - 1;
+      if (count <= 0) {
+        watchRefCounts.delete(name);
+        watchedNames.delete(name);
+        pushWatchSet();
+        if (watchedNames.size === 0) {
+          try {
+            socket?.close();
+          } catch {
+            /* noop */
+          }
+          socket = null;
+        }
+      } else {
+        watchRefCounts.set(name, count);
+      }
+    };
+  }
 
   return {
     async fetch(name: string): Promise<CompiledModule> {
@@ -136,15 +194,7 @@ export function createRemoteSource(options: RemoteSourceOptions): Source {
         listeners.delete(listener);
       };
     },
-    /**
-     * Tell the registry what bare specifiers the host's scope exposes. The
-     * registry uses this to validate that every component's imports resolve
-     * against something the host actually provides — so a typo or a forgotten
-     * scope entry is caught at push time, not at navigation time.
-     *
-     * Best-effort: failures (network, 5xx, server doesn't support /scope) are
-     * silently swallowed; they don't block the app from running.
-     */
+    watch,
     async reportScope(keys, reportedBy) {
       try {
         const baseHeaders = options.headers?.() ?? {};
@@ -154,16 +204,19 @@ export function createRemoteSource(options: RemoteSourceOptions): Source {
           body: JSON.stringify({ keys: [...keys], reportedBy }),
         });
       } catch {
-        /* best-effort: never block the host on this */
+        /* best-effort */
       }
     },
     dispose() {
       disposed = true;
+      watchedNames.clear();
+      watchRefCounts.clear();
       try {
         socket?.close();
       } catch {
         /* noop */
       }
+      socket = null;
     },
   };
 }

package/src/types.ts

@@ -103,6 +103,12 @@ export interface Source {
   fetch(name: string): Promise<CompiledModule>;
   /** Subscribe to updates for any component. Returns unsubscribe fn. */
   subscribe(listener: (update: SourceUpdate) => void): () => void;
+  /**
+   * Subscribe to live WebSocket updates for a component. Ref-counted; the
+   * socket connects lazily on the first watch and only receives pushes for
+   * watched names. Returns a release function.
+   */
+  watch?(name: string): () => void;
   /** Optional disposal hook. */
   dispose?(): void;
   /**

package/LICENSE

@@ -1,184 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship made available under
-      the License, as indicated by a copyright notice that is included in
-      or attached to the work (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean, as submitted to the Licensor for inclusion
-      in the Work by the copyright owner or by an individual or Legal Entity
-      authorized to submit on behalf of the copyright owner. For the purposes
-      of this definition, "submitted" means any form of electronic, verbal,
-      or written communication sent to the Licensor or its representatives,
-      including but not limited to communication on electronic mailing lists,
-      source code control systems, and issue tracking systems that are managed
-      by, or on behalf of, the Licensor for the purpose of developing and
-      improving the Work, but excluding communication that is conspicuously
-      marked or designated in writing by the copyright owner as "Not a
-      Contribution."
-
-      "Contributor" shall mean Licensor and any Legal Entity on behalf of
-      whom a Contribution has been received by the Licensor and incorporated
-      within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by the combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a cross-claim
-      or counterclaim in a lawsuit) alleging that the Work or any
-      Contribution embodied within the Work constitutes direct or
-      contributory patent infringement, then any patent licenses granted
-      to You under this License for that Work shall terminate as of the
-      date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, You must include a readable copy of the
-          attribution notices contained within such NOTICE file, in
-          at least one of the following places: within a NOTICE text
-          file distributed as part of the Derivative Works; within
-          the Source form or documentation, if provided along with the
-          Derivative Works; or, within a display generated by the
-          Derivative Works, if and wherever such third-party notices
-          normally appear. The contents of the NOTICE file are for
-          informational purposes only and do not modify the License.
-          You may add Your own attribution notices within Derivative
-          Works that You distribute, alongside or in addition to the
-          NOTICE text from the Work, provided that such additional
-          attribution notices cannot be construed as modifying the License.
-
-      You may add Your own license statement for Your modifications and
-      may provide additional grant of rights to use, reproduce, modify,
-      prepare Derivative Works of, convert to Object form, display,
-      perform, sublicense, and distribute the Work and such Derivative
-      Works in Source or Object form.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or exemplary damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or all other
-      commercial damages or losses), even if such Contributor has been
-      advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may offer such
-      obligations only on Your own behalf and on Your sole responsibility,
-      not on behalf of any other Contributor, and only if You agree to
-      indemnify, defend, and hold each Contributor harmless for any
-      liability incurred by, or claims asserted against, such Contributor
-      by reason of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   Copyright 2024 Omri Askenazi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.