@logixjs/react 0.1.0

package/dist/chunk-PYWHL7TA.js

@@ -0,0 +1,351 @@
+import {
+  RuntimeProviderNotFoundError,
+  makeModuleActions,
+  makeModuleDispatchers,
+  resolveImportedModuleRef,
+  useModuleRuntime,
+  useRuntime,
+  useStableId
+} from "./chunk-UFFCJGSZ.js";
+import {
+  RuntimeContext,
+  getModuleCache,
+  isDevEnv,
+  stableHash
+} from "./chunk-2WFULYPJ.js";
+
+// src/internal/hooks/useLocalModule.ts
+import React, { useEffect, useMemo } from "react";
+import * as Logix from "@logixjs/core";
+import { Context, Effect, Layer, Scope } from "effect";
+function isModuleTag(source) {
+  if (!source || typeof source !== "object" && typeof source !== "function") {
+    return false;
+  }
+  const candidate = source;
+  return candidate._kind === "ModuleTag";
+}
+function useLocalModule(source, second) {
+  const runtime = useRuntime();
+  const runtimeContext = React.useContext(RuntimeContext);
+  if (!runtimeContext) {
+    throw new RuntimeProviderNotFoundError("useLocalModule");
+  }
+  const cache = useMemo(
+    () => getModuleCache(runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
+    [runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion]
+  );
+  const componentId = useStableId();
+  const moduleTag = React.useMemo(() => {
+    if (Logix.Module.is(source)) {
+      return source.tag;
+    }
+    if (isModuleTag(source)) {
+      return source;
+    }
+    return null;
+  }, [source]);
+  const def = React.useMemo(() => {
+    if (Logix.Module.is(source) || isModuleTag(source)) {
+      return source;
+    }
+    return void 0;
+  }, [source]);
+  const isModule = moduleTag !== null;
+  const moduleOptions = isModule ? second : void 0;
+  const deps = isModule ? moduleOptions?.deps ?? [] : second ?? [];
+  const { key, ownerId } = useMemo(() => {
+    const depsHash = stableHash(deps);
+    if (isModule) {
+      const module = moduleTag;
+      const baseKey = moduleOptions?.key ?? module.id ?? "module";
+      return {
+        key: `local:${baseKey}:${componentId}:${depsHash}`,
+        ownerId: module.id ?? "Module"
+      };
+    }
+    return {
+      key: `local:factory:${componentId}:${depsHash}`,
+      ownerId: void 0
+    };
+  }, [isModule, moduleTag, moduleOptions?.key, deps, componentId]);
+  const factory = useMemo(() => {
+    if (isModule) {
+      return createModuleTagFactory(moduleTag, moduleOptions);
+    }
+    const factoryFn = source;
+    return (scope) => factoryFn().pipe(Scope.extend(scope));
+  }, [isModule, moduleTag, source, moduleOptions]);
+  const moduleRuntime = cache.readSync(key, factory, void 0, ownerId, {
+    entrypoint: "react.useLocalModule",
+    policyMode: runtimeContext.policy.mode,
+    warnSyncBlockingThresholdMs: 5
+  });
+  useEffect(() => cache.retain(key), [cache, key]);
+  const dispatch = useMemo(() => {
+    const base = (action) => {
+      runtime.runFork(moduleRuntime.dispatch(action));
+    };
+    return Object.assign(base, {
+      batch: (actions2) => {
+        runtime.runFork(moduleRuntime.dispatchBatch(actions2));
+      },
+      lowPriority: (action) => {
+        runtime.runFork(moduleRuntime.dispatchLowPriority(action));
+      }
+    });
+  }, [runtime, moduleRuntime]);
+  const tokens = useMemo(() => {
+    if (!def || typeof def !== "object" && typeof def !== "function") {
+      return void 0;
+    }
+    const candidate = def;
+    if (!candidate.actions || typeof candidate.actions !== "object") {
+      return void 0;
+    }
+    return candidate.actions;
+  }, [def]);
+  const actions = useMemo(() => makeModuleActions(dispatch), [dispatch]);
+  const dispatchers = useMemo(
+    () => tokens ? makeModuleDispatchers(dispatch, tokens) : makeModuleDispatchers(dispatch),
+    [dispatch, tokens]
+  );
+  return useMemo(
+    () => ({
+      def,
+      runtime: moduleRuntime,
+      dispatch,
+      actions,
+      dispatchers,
+      imports: {
+        get: (module) => resolveImportedModuleRef(runtime, moduleRuntime, module)
+      },
+      getState: moduleRuntime.getState,
+      setState: moduleRuntime.setState,
+      actions$: moduleRuntime.actions$,
+      changes: moduleRuntime.changes,
+      ref: moduleRuntime.ref
+    }),
+    [runtime, moduleRuntime, dispatch, actions, dispatchers, def]
+  );
+}
+function createModuleTagFactory(module, options) {
+  if (!options || options.initial === void 0) {
+    throw new Error("useLocalModule(module, options) \u9700\u8981\u63D0\u4F9B initial \u72B6\u6001");
+  }
+  const logics = options.logics ?? [];
+  return (scope) => Layer.buildWithScope(module.live(options.initial, ...logics), scope).pipe(
+    Effect.map((context) => {
+      const runtime = Context.get(context, module);
+      return runtime;
+    })
+  );
+}
+
+// src/internal/hooks/useLayerModule.ts
+import React2 from "react";
+import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
+function useLayerModule(module, layer, deps = []) {
+  const factory = React2.useCallback(
+    () => Layer2.build(layer).pipe(
+      Effect2.scoped,
+      Effect2.map((context) => Context2.get(context, module))
+    ),
+    // layer/module are typically constants; deps lets callers opt into rebuilding when needed.
+    [layer, module]
+  );
+  return useLocalModule(factory, deps);
+}
+
+// src/internal/hooks/useDispatch.ts
+import { useMemo as useMemo2 } from "react";
+function useDispatch(handle) {
+  const runtime = useRuntime();
+  const moduleRuntime = useModuleRuntime(handle);
+  return useMemo2(() => {
+    const base = (action) => {
+      runtime.runFork(moduleRuntime.dispatch(action));
+    };
+    return Object.assign(base, {
+      batch: (actions) => {
+        runtime.runFork(moduleRuntime.dispatchBatch(actions));
+      },
+      lowPriority: (action) => {
+        runtime.runFork(moduleRuntime.dispatchLowPriority(action));
+      }
+    });
+  }, [runtime, moduleRuntime]);
+}
+
+// src/internal/hooks/useModuleList.ts
+import { useMemo as useMemo3, useRef } from "react";
+function useModuleList(items, keyFn, factory) {
+  const cache = useMemo3(() => /* @__PURE__ */ new Map(), []);
+  const keyFnRef = useRef(keyFn);
+  keyFnRef.current = keyFn;
+  const factoryRef = useRef(factory);
+  factoryRef.current = factory;
+  return useMemo3(() => {
+    return items.map((item) => {
+      const key = keyFnRef.current(item);
+      if (!cache.has(key)) {
+        cache.set(key, factoryRef.current(key, item));
+      }
+      return cache.get(key);
+    });
+  }, [items, cache]);
+}
+
+// src/internal/hooks/useImportedModule.ts
+import React3 from "react";
+function useImportedModule(parent, module) {
+  const runtime = useRuntime();
+  const parentRuntime = useModuleRuntime(parent);
+  return React3.useMemo(() => resolveImportedModuleRef(runtime, parentRuntime, module), [runtime, parentRuntime, module]);
+}
+
+// src/internal/hooks/useProcesses.ts
+import React4, { useContext, useEffect as useEffect2, useMemo as useMemo4, useRef as useRef2 } from "react";
+import { Effect as Effect3, Exit, Scope as Scope2 } from "effect";
+import * as Logix2 from "@logixjs/core";
+var ProcessSubtreeRegistry = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  retain(args) {
+    const existing = this.entries.get(args.key);
+    if (existing) {
+      if (existing.signature !== args.signature) {
+        throw new Error(
+          `[useProcesses] subtreeId "${args.key}" has already been claimed by a different process set. previous="${existing.signature}" current="${args.signature}". Use a different subtreeId or keep the processes list stable for the same subtree.`
+        );
+      }
+      existing.refCount += 1;
+      if (existing.gcTimeout) {
+        clearTimeout(existing.gcTimeout);
+        existing.gcTimeout = void 0;
+      }
+      return () => this.release({ key: args.key, gcTime: args.gcTime });
+    }
+    const scope = Effect3.runSync(Scope2.make());
+    const entry = {
+      key: args.key,
+      signature: args.signature,
+      scope,
+      refCount: 1
+    };
+    this.entries.set(args.key, entry);
+    args.install(scope);
+    return () => this.release({ key: args.key, gcTime: args.gcTime });
+  }
+  release(args) {
+    const entry = this.entries.get(args.key);
+    if (!entry) return;
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    if (entry.refCount > 0) return;
+    this.scheduleGC(entry, args.gcTime);
+  }
+  scheduleGC(entry, gcTime) {
+    if (entry.gcTimeout) return;
+    if (!Number.isFinite(gcTime)) {
+      return;
+    }
+    const timeoutMs = gcTime <= 0 ? 0 : gcTime;
+    entry.gcTimeout = setTimeout(() => {
+      const current = this.entries.get(entry.key);
+      if (!current || current !== entry) return;
+      if (current.refCount > 0) return;
+      void this.runtime.runPromise(Scope2.close(entry.scope, Exit.void)).catch(() => {
+      });
+      this.entries.delete(entry.key);
+    }, timeoutMs);
+  }
+};
+var RUNTIME_PROCESS_REGISTRY = /* @__PURE__ */ new WeakMap();
+var getRegistry = (runtime) => {
+  const existing = RUNTIME_PROCESS_REGISTRY.get(runtime);
+  if (existing) return existing;
+  const created = new ProcessSubtreeRegistry(runtime);
+  RUNTIME_PROCESS_REGISTRY.set(runtime, created);
+  return created;
+};
+var stableProcessSignature = (processes) => {
+  const ids = [];
+  for (let i = 0; i < processes.length; i++) {
+    const def = Logix2.Process.getDefinition(processes[i]);
+    ids.push(def?.processId ?? `legacy#${i}`);
+  }
+  return ids.join("|");
+};
+function useProcesses(processes, options) {
+  const context = useContext(RuntimeContext);
+  if (!context) {
+    throw new RuntimeProviderNotFoundError("useProcesses");
+  }
+  const isDev = isDevEnv();
+  const lastProcessesRef = useRef2(null);
+  const shallowEqualProcesses = (a, b) => !!a && !!b && a.length === b.length && a.every((item, idx) => item === b[idx]);
+  useEffect2(() => {
+    if (!isDev) return;
+    if (!lastProcessesRef.current) {
+      lastProcessesRef.current = processes;
+      return;
+    }
+    if (lastProcessesRef.current !== processes && !shallowEqualProcesses(lastProcessesRef.current, processes)) {
+      console.warn(
+        "[useProcesses] received a new processes list. Memoize the list (useMemo) to avoid unnecessary install/uninstall churn."
+      );
+    }
+    lastProcessesRef.current = processes;
+  }, [isDev, processes]);
+  const defaultSubtreeId = React4.useId();
+  const subtreeId = options?.subtreeId ?? `ui:${defaultSubtreeId}`;
+  const signature = useMemo4(() => stableProcessSignature(processes), [processes]);
+  const gcTime = options?.gcTime ?? context.reactConfigSnapshot.gcTime;
+  const mode = options?.mode ?? "switch";
+  const deps = options?.deps ? [...options.deps, context.runtime, subtreeId, signature, gcTime, mode] : [context.runtime, subtreeId, signature, gcTime, mode];
+  useEffect2(() => {
+    if (!processes || processes.length === 0) {
+      return;
+    }
+    const runtime = context.runtime;
+    const registry = getRegistry(runtime);
+    return registry.retain({
+      key: subtreeId,
+      signature,
+      gcTime,
+      install: (scope) => {
+        const program = Effect3.forEach(
+          processes,
+          (process) => Logix2.InternalContracts.installProcess(process, {
+            scope: { type: "uiSubtree", subtreeId },
+            enabled: true,
+            installedAt: "uiSubtree",
+            mode
+          }).pipe(
+            Effect3.flatMap((installation) => {
+              if (installation !== void 0) {
+                return Effect3.void;
+              }
+              return Effect3.forkScoped(process).pipe(Effect3.asVoid);
+            }),
+            Effect3.catchAll(() => Effect3.forkScoped(process).pipe(Effect3.asVoid))
+          ),
+          { discard: true }
+        ).pipe(Effect3.provideService(Scope2.Scope, scope));
+        void runtime.runPromise(program).catch(() => {
+        });
+      }
+    });
+  }, deps);
+}
+
+export {
+  useLocalModule,
+  useLayerModule,
+  useDispatch,
+  useModuleList,
+  useImportedModule,
+  useProcesses
+};