@logixjs/react 0.1.0

package/dist/chunk-4G7H66OY.js

@@ -0,0 +1,54 @@
+import {
+  useDispatch,
+  useLocalModule
+} from "./chunk-PYWHL7TA.js";
+import {
+  useModule,
+  useSelector
+} from "./chunk-UFFCJGSZ.js";
+import {
+  RuntimeProvider
+} from "./chunk-JXAJTWSZ.js";
+
+// src/ReactPlatform.ts
+import React from "react";
+var ReactPlatform = {
+  /**
+   * Creates a React component that provides the Logix runtime to its children.
+   */
+  Provider: RuntimeProvider,
+  /**
+   * Hook to use a module from the provided runtime.
+   */
+  useModule,
+  /**
+   * Hook to create and use a local module instance.
+   */
+  useLocalModule,
+  /**
+   * Hook to select a slice of state from a module.
+   */
+  useSelector,
+  /**
+   * Hook to get the dispatch function for a module.
+   */
+  useDispatch,
+  /**
+   * Creates a root provider component for a given runtime.
+   *
+   * The caller is responsible for constructing and managing the Runtime lifecycle
+   * (typically via Logix.Runtime.make). ReactPlatform only provides that Runtime within the React tree.
+   */
+  createRoot: (runtime) => {
+    return ({ children }) => {
+      return React.createElement(RuntimeProvider, {
+        runtime,
+        children
+      });
+    };
+  }
+};
+
+export {
+  ReactPlatform
+};

package/dist/chunk-G5MRIFKK.js

@@ -0,0 +1,95 @@
+import {
+  useModule,
+  useRuntime
+} from "./chunk-UFFCJGSZ.js";
+import {
+  RuntimeProvider
+} from "./chunk-JXAJTWSZ.js";
+
+// src/ModuleScope.ts
+import React from "react";
+import * as Logix from "@logixjs/core";
+var makeModuleScope = (handle, defaults) => {
+  const Context = React.createContext(null);
+  const toUseModuleOptions = (options) => {
+    const { scopeId, ...rest } = options;
+    return scopeId != null ? { ...rest, key: scopeId } : rest;
+  };
+  const getRegistryOrThrow = (runtime, where) => {
+    try {
+      const registry = runtime.runSync(Logix.ScopeRegistry.ScopeRegistryTag);
+      if (!registry) {
+        throw new Error("ScopeRegistry service is undefined");
+      }
+      return registry;
+    } catch {
+      throw new Error(
+        `${where} Missing Logix.ScopeRegistry in current runtime. If you are using Logix.Runtime.make, it should be provided by default. If you are using ManagedRuntime.make, include Logix.ScopeRegistry.layer() in your Layer.`
+      );
+    }
+  };
+  const moduleToken = Logix.Module.hasImpl(handle) ? handle.tag : handle.module;
+  const Provider = ({ children, options }) => {
+    const runtime = useRuntime();
+    const merged = defaults || options ? { ...defaults ?? {}, ...options ?? {} } : void 0;
+    const ref = merged ? useModule(handle, toUseModuleOptions(merged)) : useModule(handle);
+    const scopeId = merged?.scopeId;
+    React.useEffect(() => {
+      if (!scopeId) return;
+      const registry = getRegistryOrThrow(runtime, "[ModuleScope]");
+      const leaseRuntime = registry.register(scopeId, Logix.ScopeRegistry.ScopedRuntimeTag, runtime);
+      const leaseModule = registry.register(scopeId, moduleToken, ref.runtime);
+      return () => {
+        leaseModule.release();
+        leaseRuntime.release();
+      };
+    }, [runtime, scopeId, ref.runtime]);
+    return React.createElement(Context.Provider, { value: ref }, children);
+  };
+  const use = () => {
+    const ref = React.useContext(Context);
+    if (!ref) {
+      throw new Error("[ModuleScope] Provider not found");
+    }
+    return ref;
+  };
+  const useImported = (module) => {
+    const host = use();
+    return host.imports.get(module);
+  };
+  const Bridge = ({ scopeId, children }) => {
+    const runtime = useRuntime();
+    const registry = getRegistryOrThrow(runtime, "[ModuleScope.Bridge]");
+    const scopedRuntime = registry.get(scopeId, Logix.ScopeRegistry.ScopedRuntimeTag);
+    const moduleRuntime = registry.get(
+      scopeId,
+      moduleToken
+    );
+    if (!scopedRuntime || !moduleRuntime) {
+      throw new Error(
+        `[ModuleScope.Bridge] Scope "${scopeId}" is not registered (or has been disposed). Ensure you have a corresponding <ModuleScope.Provider options={{ scopeId }}> mounted.`
+      );
+    }
+    return React.createElement(
+      RuntimeProvider,
+      { runtime: scopedRuntime },
+      React.createElement(BridgeInner, { moduleRuntime, Context }, children)
+    );
+  };
+  const BridgeInner = ({
+    moduleRuntime,
+    Context: Context2,
+    children
+  }) => {
+    const ref = useModule(moduleRuntime);
+    return React.createElement(Context2.Provider, { value: ref }, children);
+  };
+  return { Provider, use, useImported, Context, Bridge };
+};
+var ModuleScope = {
+  make: makeModuleScope
+};
+
+export {
+  ModuleScope
+};