@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-5GEYCJW2.js

@@ -0,0 +1,206 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  isLogicPlanEffect,
+  make as make2,
+  markAsLogicPlanEffect
+} from "./chunk-KTFZSXOW.js";
+import {
+  LogicPhaseServiceTag,
+  LogicUnitServiceTag,
+  make
+} from "./chunk-RIWOEI3T.js";
+
+// ../logix-core/src/internal/runtime/ModuleFactory.ts
+import { Context, Effect, Layer, Option, Schema } from "../effect.js";
+function Link(modules, logic) {
+  return Effect.gen(function* () {
+    const handles = {};
+    for (const [key, module] of Object.entries(modules)) {
+      const runtime = yield* module;
+      handles[key] = {
+        read: (selector) => Effect.map(runtime.getState, selector),
+        changes: runtime.changes,
+        dispatch: runtime.dispatch,
+        actions$: runtime.actions$,
+        actions: new Proxy(
+          {},
+          {
+            get: (_target, prop) => (payload) => runtime.dispatch({ _tag: prop, payload })
+          }
+        )
+      };
+    }
+    return yield* logic(
+      handles
+    );
+  });
+}
+function Module(id, def) {
+  const shape = {
+    stateSchema: def.state,
+    actionSchema: Schema.Union(
+      ...Object.entries(def.actions).map(([tag2, token]) => {
+        const payload = token.schema;
+        return Schema.Struct(
+          payload === Schema.Void ? {
+            _tag: Schema.Literal(tag2),
+            payload: Schema.optional(payload)
+          } : {
+            _tag: Schema.Literal(tag2),
+            payload
+          }
+        );
+      })
+    ),
+    actionMap: def.actions
+  };
+  const reducers = def.reducers && Object.fromEntries(
+    Object.entries(def.reducers).map(([tag2, reducer]) => [
+      tag2,
+      (state, action, sink) => (
+        // Relies on the runtime `_tag` convention: only actions matching the current tag are routed to this reducer.
+        reducer(
+          state,
+          action,
+          sink
+        )
+      )
+    ])
+  );
+  class ModuleTag extends Context.Tag(`@logixjs/Module/${id}`)() {
+  }
+  const tag = ModuleTag;
+  const moduleTag = Object.assign(tag, {
+    _kind: "ModuleTag",
+    id,
+    shape,
+    stateSchema: shape.stateSchema,
+    actionSchema: shape.actionSchema,
+    actions: shape.actionMap,
+    reducers: def.reducers,
+    /**
+     * Build a Logic program for the current Module:
+     * - Read its ModuleRuntime from Context at runtime.
+     * - Build a BoundApi from the runtime.
+     * - Pass the BoundApi to the caller to build business logic.
+     */
+    logic: (build) => {
+      const logicEffect = Effect.gen(function* () {
+        const runtime = yield* tag;
+        const logicUnit = yield* Effect.serviceOption(LogicUnitServiceTag).pipe(
+          Effect.map(Option.getOrUndefined)
+        );
+        const phaseService = yield* Effect.serviceOption(LogicPhaseServiceTag).pipe(
+          Effect.map(Option.getOrUndefined)
+        );
+        const api = make(shape, runtime, {
+          getPhase: () => phaseService?.current ?? "run",
+          phaseService,
+          moduleId: id,
+          logicUnit
+        });
+        let built;
+        try {
+          built = build(api);
+        } catch (err) {
+          if (err?._tag === "LogicPhaseError") {
+            return yield* Effect.fail(err);
+          }
+          throw err;
+        }
+        if (isLogicPlanEffect(built)) {
+          return yield* built;
+        }
+        const isLogicPlan = (value) => Boolean(value && typeof value === "object" && "setup" in value && "run" in value);
+        const plan = isLogicPlan(built) ? built : {
+          setup: Effect.void,
+          run: built
+        };
+        return plan;
+      });
+      markAsLogicPlanEffect(logicEffect);
+      return logicEffect;
+    },
+    /**
+     * live: given an initial state and a set of logics, construct a scoped ModuleRuntime Layer.
+     *
+     * Env conventions:
+     * - R represents extra environment required by the logics (services / platform, etc.).
+     * - ModuleRuntime itself only depends on Scope.Scope and is managed by Layer.scoped.
+     */
+    live: (initial, ...logics) => Layer.scoped(
+      tag,
+      make2(initial, {
+        tag,
+        logics,
+        moduleId: id,
+        reducers
+      })
+    ),
+    /**
+     * implement: build a ModuleImpl blueprint from Module definition + initial state + a set of logics.
+     *
+     * - R represents the Env required by the logics.
+     * - The returned ModuleImpl.layer carries R as its input environment.
+     * - withLayer/withLayers can progressively narrow R to a more concrete Env (even never).
+     */
+    implement: (config) => {
+      const importedModules = (config.imports ?? []).flatMap((item) => {
+        if (item._tag === "ModuleImpl") {
+          return [
+            item.module
+          ];
+        }
+        return [];
+      });
+      const baseLayer = Layer.scoped(
+        tag,
+        make2(config.initial, {
+          tag,
+          logics: config.logics || [],
+          processes: config.processes || [],
+          moduleId: id,
+          imports: importedModules,
+          reducers,
+          stateTransaction: config.stateTransaction
+        })
+      );
+      const processes = config.processes ?? [];
+      const makeImplWithLayer = (layer) => ({
+        _tag: "ModuleImpl",
+        module: moduleTag,
+        layer,
+        processes,
+        stateTransaction: config.stateTransaction,
+        withLayer: (extra) => {
+          const provided = layer.pipe(Layer.provide(extra));
+          const merged = Layer.mergeAll(provided, extra);
+          return makeImplWithLayer(merged);
+        },
+        withLayers: (...extras) => extras.reduce(
+          (implAcc, extra) => implAcc.withLayer(extra),
+          makeImplWithLayer(
+            layer
+          )
+        )
+      });
+      const initialImpl = makeImplWithLayer(
+        baseLayer
+      );
+      const imports = config.imports ?? [];
+      const finalImpl = imports.reduce((implAcc, item) => {
+        const layer = item._tag === "ModuleImpl" ? item.layer : item;
+        return implAcc.withLayer(layer);
+      }, initialImpl);
+      return finalImpl;
+    }
+  });
+  return moduleTag;
+}
+
+export {
+  Link,
+  Module
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/ModuleFactory.ts"],
  "sourcesContent": ["import { Context, Effect, Layer, Option, Schema } from 'effect'\nimport * as ModuleRuntimeImpl from './ModuleRuntime.js'\nimport * as BoundApiRuntime from './BoundApiRuntime.js'\nimport * as LogicDiagnostics from './core/LogicDiagnostics.js'\nimport * as LogicPlanMarker from './core/LogicPlanMarker.js'\nimport type * as Action from '../action.js'\nimport type { FieldPath } from '../field-path.js'\nimport type {\n  AnyModuleShape,\n  AnySchema,\n  ActionsFromMap,\n  ModuleTag as LogixModuleTag,\n  ModuleShape,\n  ReducersFromMap,\n  StateOf,\n  ActionOf,\n  ModuleHandle,\n  ModuleLogic,\n  ModuleImpl,\n  ModuleImplementStateTransactionOptions,\n} from './core/module.js'\n\n/**\n * v3: Link (formerly Orchestrator)\n * A glue layer for cross-module collaboration.\n *\n * - Does not own its own State.\n * - Can access multiple Modules' readonly handles.\n * - Can define Logic only; cannot define State/Action.\n */\nexport function Link<Modules extends Record<string, LogixModuleTag<any, AnyModuleShape>>, E = never, R = never>(\n  modules: Modules,\n  logic: ($: { [K in keyof Modules]: ModuleHandle<Modules[K]['shape']> }) => Effect.Effect<void, E, R>,\n): Effect.Effect<void, E, R> {\n  return Effect.gen(function* () {\n    const handles: Record<string, ModuleHandle<AnyModuleShape>> = {}\n\n    for (const [key, module] of Object.entries(modules)) {\n      const runtime = yield* module\n\n      handles[key] = {\n        read: (selector: any) => Effect.map(runtime.getState, selector),\n        changes: runtime.changes,\n        dispatch: runtime.dispatch,\n        actions$: runtime.actions$,\n        actions: new Proxy(\n          {},\n          {\n            get: (_target, prop) => (payload: any) => runtime.dispatch({ _tag: prop as string, payload }),\n          },\n        ),\n      }\n    }\n\n    return yield* logic(\n      handles as {\n        [K in keyof Modules]: ModuleHandle<Modules[K]['shape']>\n      },\n    )\n  })\n}\n\n/**\n * Module factory implementation: construct a ModuleTag from an id and Schema definitions.\n */\nexport function Module<Id extends string, SSchema extends AnySchema, AMap extends Record<string, Action.AnyActionToken>>(\n  id: Id,\n  def: {\n    readonly state: SSchema\n    readonly actions: AMap\n    readonly reducers?: ReducersFromMap<SSchema, AMap>\n  },\n): LogixModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>> {\n  const shape: ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap> = {\n    stateSchema: def.state as any,\n    actionSchema: Schema.Union(\n      ...Object.entries(def.actions).map(([tag, token]) => {\n        const payload = (token as Action.AnyActionToken).schema as AnySchema\n        return Schema.Struct(\n          payload === Schema.Void\n            ? {\n                _tag: Schema.Literal(tag),\n                payload: Schema.optional(payload),\n              }\n            : {\n                _tag: Schema.Literal(tag),\n                payload,\n              },\n        )\n      }),\n    ) as unknown as Schema.Schema<ActionsFromMap<AMap>>,\n    actionMap: def.actions as any,\n  }\n\n  type ShapeState = StateOf<typeof shape>\n  type ShapeAction = ActionOf<typeof shape>\n\n  // Normalize tag-keyed reducers into `_tag -> (state, action, sink?) => state` for the runtime.\n  const reducers =\n    def.reducers &&\n    (Object.fromEntries(\n      Object.entries(def.reducers).map(([tag, reducer]) => [\n        tag,\n        (state: ShapeState, action: ShapeAction, sink?: (path: string | FieldPath) => void) =>\n          // Relies on the runtime `_tag` convention: only actions matching the current tag are routed to this reducer.\n          (reducer as any)(\n            state,\n            action as {\n              readonly _tag: string\n              readonly payload: unknown\n            },\n            sink,\n          ) as ShapeState,\n      ]),\n    ) as Record<\n      string,\n      (state: ShapeState, action: ShapeAction, sink?: (path: string | FieldPath) => void) => ShapeState\n    >)\n\n  class ModuleTag extends Context.Tag(`@logixjs/Module/${id}`)<\n    ModuleTag,\n    import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>\n  >() {}\n\n  const tag = ModuleTag\n\n  const moduleTag = Object.assign(tag, {\n    _kind: 'ModuleTag' as const,\n    id,\n    shape,\n    stateSchema: shape.stateSchema,\n    actionSchema: shape.actionSchema,\n    actions: shape.actionMap,\n    reducers: def.reducers,\n    /**\n     * Build a Logic program for the current Module:\n     * - Read its ModuleRuntime from Context at runtime.\n     * - Build a BoundApi from the runtime.\n     * - Pass the BoundApi to the caller to build business logic.\n     */\n    logic: <R = unknown, E = never>(\n      build: (api: import('./core/module.js').BoundApi<typeof shape, R>) => ModuleLogic<typeof shape, R, E>,\n    ): ModuleLogic<typeof shape, R, E> => {\n      const logicEffect = Effect.gen(function* () {\n        const runtime = yield* tag\n        const logicUnit = yield* Effect.serviceOption(LogicDiagnostics.LogicUnitServiceTag).pipe(\n          Effect.map(Option.getOrUndefined),\n        )\n        const phaseService = yield* Effect.serviceOption(LogicDiagnostics.LogicPhaseServiceTag).pipe(\n          Effect.map(Option.getOrUndefined),\n        )\n        const api = BoundApiRuntime.make<typeof shape, R>(shape, runtime, {\n          getPhase: () => phaseService?.current ?? 'run',\n          phaseService,\n          moduleId: id,\n          logicUnit,\n        })\n\n        let built: unknown\n        try {\n          built = build(api)\n        } catch (err) {\n          // Convert synchronously thrown LogicPhaseError into Effect.fail so runSync won't treat it as an \"async pending fiber\".\n          if ((err as any)?._tag === 'LogicPhaseError') {\n            return yield* Effect.fail(err as any)\n          }\n          throw err\n        }\n\n        if (LogicPlanMarker.isLogicPlanEffect(built)) {\n          return yield* built as Effect.Effect<any, any, any>\n        }\n\n        const isLogicPlan = (value: unknown): value is import('./core/module.js').LogicPlan<typeof shape, R, E> =>\n          Boolean(value && typeof value === 'object' && 'setup' in (value as any) && 'run' in (value as any))\n\n        const plan = isLogicPlan(built)\n          ? built\n          : ({\n              setup: Effect.void,\n              run: built as Effect.Effect<any, any, any>,\n            } satisfies import('./core/module.js').LogicPlan<typeof shape, R, E>)\n\n        return plan\n      })\n\n      LogicPlanMarker.markAsLogicPlanEffect(logicEffect)\n      return logicEffect\n    },\n\n    /**\n     * live: given an initial state and a set of logics, construct a scoped ModuleRuntime Layer.\n     *\n     * Env conventions:\n     * - R represents extra environment required by the logics (services / platform, etc.).\n     * - ModuleRuntime itself only depends on Scope.Scope and is managed by Layer.scoped.\n     */\n    live: <R = never, E = never>(\n      initial: StateOf<typeof shape>,\n      ...logics: Array<ModuleLogic<typeof shape, R, E>>\n    ): Layer.Layer<import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>, E, R> =>\n      Layer.scoped(\n        tag,\n        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(initial, {\n          tag,\n          logics: logics as ReadonlyArray<Effect.Effect<any, any, any>>,\n          moduleId: id,\n          reducers,\n        }),\n      ) as unknown as Layer.Layer<\n        import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n        E,\n        R\n      >,\n\n    /**\n     * implement: build a ModuleImpl blueprint from Module definition + initial state + a set of logics.\n     *\n     * - R represents the Env required by the logics.\n     * - The returned ModuleImpl.layer carries R as its input environment.\n     * - withLayer/withLayers can progressively narrow R to a more concrete Env (even never).\n     */\n    implement: <R = never>(config: {\n      initial: StateOf<typeof shape>\n      logics?: Array<ModuleLogic<typeof shape, R, never>>\n      imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n      /**\n       * processes: a set of long-lived flows bound to this Module implementation (including Link).\n       *\n       * - These Effects will be forked by the runtime container (e.g. Runtime.make).\n       * - Types use relaxed E/R to enable composing cross-module orchestration logic.\n       * - Business code typically builds these flows via Link.make.\n       */\n      processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n      /**\n       * stateTransaction: module-level StateTransaction config.\n       *\n       * - If instrumentation is not provided, fall back to Runtime-level config (if any) or NODE_ENV defaults.\n       * - If instrumentation is provided, it takes precedence over Runtime-level config and defaults.\n       */\n      stateTransaction?: ModuleImplementStateTransactionOptions\n    }): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, R> => {\n      const importedModules = (config.imports ?? []).flatMap((item) => {\n        if ((item as ModuleImpl<any, AnyModuleShape, any>)._tag === 'ModuleImpl') {\n          return [\n            (item as ModuleImpl<any, AnyModuleShape, any>).module as unknown as Context.Tag<\n              any,\n              import('./core/module.js').ModuleRuntime<any, any>\n            >,\n          ]\n        }\n        return []\n      })\n\n      const baseLayer = Layer.scoped(\n        tag,\n        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(config.initial, {\n          tag,\n          logics: (config.logics || []) as ReadonlyArray<Effect.Effect<any, any, any>>,\n          processes: (config.processes || []) as ReadonlyArray<Effect.Effect<void, any, any>>,\n          moduleId: id,\n          imports: importedModules,\n          reducers,\n          stateTransaction: config.stateTransaction,\n        }),\n      ) as unknown as Layer.Layer<\n        import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n        never,\n        any\n      >\n\n      const processes = config.processes ?? []\n\n      const makeImplWithLayer = (\n        layer: Layer.Layer<\n          import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n          never,\n          any\n        >,\n      ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> => ({\n        _tag: 'ModuleImpl',\n        module: moduleTag as unknown as LogixModuleTag<\n          Id,\n          ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>\n        >,\n        layer,\n        processes,\n        stateTransaction: config.stateTransaction,\n        withLayer: (\n          extra: Layer.Layer<any, never, any>,\n        ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> => {\n          const provided = (\n            layer as Layer.Layer<\n              import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n              never,\n              any\n            >\n          ).pipe(Layer.provide(extra as Layer.Layer<any, never, any>))\n\n          const merged = Layer.mergeAll(provided, extra as Layer.Layer<any, never, any>) as Layer.Layer<\n            import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n            never,\n            any\n          >\n\n          return makeImplWithLayer(merged)\n        },\n        withLayers: (\n          ...extras: ReadonlyArray<Layer.Layer<any, never, any>>\n        ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> =>\n          extras.reduce<ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any>>(\n            (implAcc, extra) => implAcc.withLayer(extra),\n            makeImplWithLayer(\n              layer as Layer.Layer<\n                import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n                never,\n                any\n              >,\n            ),\n          ),\n      })\n\n      // Start from baseLayer and layer-in imports (Layer or other ModuleImpl.layer) sequentially.\n      const initialImpl = makeImplWithLayer(\n        baseLayer as Layer.Layer<\n          import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n          never,\n          any\n        >,\n      )\n\n      const imports = config.imports ?? []\n\n      const finalImpl = imports.reduce<\n        ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any>\n      >((implAcc, item) => {\n        const layer =\n          (item as ModuleImpl<any, AnyModuleShape, any>)._tag === 'ModuleImpl'\n            ? (item as ModuleImpl<any, AnyModuleShape, any>).layer\n            : (item as Layer.Layer<any, any, any>)\n\n        return implAcc.withLayer(layer as Layer.Layer<any, never, any>)\n      }, initialImpl)\n\n      return finalImpl\n    },\n  })\n\n  return moduleTag as LogixModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>>\n}\n"],
  "mappings": "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",
  "names": ["tag", "make"]
}
