@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-KFE3JO6N.js

@@ -0,0 +1,77 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-XE7ULSGQ.js";
+
+// ../logix-core/src/internal/root.ts
+import { Context as Context2, Deferred as Deferred2, Effect, Layer } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/RootContext.ts
+import { Context } from "../effect.js";
+var RootContextTagImpl = class extends Context.Tag("@logix/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// ../logix-core/src/internal/root.ts
+var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
+var makeMissingRootProviderError = (tag, entrypoint, extra) => {
+  const dev = isDevEnv();
+  const tokenId = tagIdOf(tag);
+  const fix = dev ? [
+    "- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).",
+    "- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).",
+    "- Do not rely on nested RuntimeProvider.layer to mock Root.resolve."
+  ] : [];
+  const message = dev ? [
+    "[MissingRootProviderError] Cannot resolve Tag from root provider.",
+    extra ? `
+${extra}` : "",
+    `tokenId: ${tokenId}`,
+    `entrypoint: ${entrypoint}`,
+    "mode: global",
+    "startScope: root",
+    "",
+    "fix:",
+    ...fix
+  ].filter((s) => s.length > 0).join("\n") : "[MissingRootProviderError] tag not found in root provider";
+  const err = new Error(message);
+  err.name = "MissingRootProviderError";
+  err.tokenId = tokenId;
+  err.entrypoint = entrypoint;
+  err.mode = "global";
+  err.startScope = { kind: "root" };
+  err.fix = fix;
+  return err;
+};
+var resolve = (tag, options) => Effect.gen(function* () {
+  const entrypoint = options?.entrypoint ?? "logic.root.resolve";
+  const root = yield* RootContextTag;
+  const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
+  if (!rootContext) {
+    return yield* Effect.die(
+      makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
+    );
+  }
+  try {
+    return Context2.get(rootContext, tag);
+  } catch {
+    return yield* Effect.die(makeMissingRootProviderError(tag, entrypoint));
+  }
+});
+var layerFromContext = (context) => Layer.scoped(
+  RootContextTag,
+  Effect.gen(function* () {
+    const ready = yield* Deferred2.make();
+    yield* Deferred2.succeed(ready, context);
+    const root = { context, ready };
+    return root;
+  })
+);
+
+export {
+  RootContextTag,
+  resolve,
+  layerFromContext
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/root.ts", "../../../../logix-core/src/internal/runtime/core/RootContext.ts"],
  "sourcesContent": ["import { Context, Deferred, Effect, Layer } from 'effect'\nimport { isDevEnv } from './runtime/core/env.js'\nimport { RootContextTag, type RootContext } from './runtime/core/RootContext.js'\n\nexport type RootResolveEntrypoint = 'logic.root.resolve' | 'logic.$.root.resolve'\n\nexport interface RootResolveOptions {\n  readonly entrypoint?: RootResolveEntrypoint\n  /**\n   * \u662F\u5426\u5141\u8BB8\u5728 RootContext \u5C1A\u672A\u5C31\u7EEA\u65F6\u7B49\u5F85\uFF1A\n   * - \u9ED8\u8BA4 false\uFF1A\u907F\u514D\u5728 layer/setup \u9636\u6BB5\u8BEF\u7528\u5BFC\u81F4\u6B7B\u9501\uFF1B\n   * - `$.root.resolve` \u4F1A\u5728 run \u9636\u6BB5\u4F20 true\uFF08run-only\uFF09\uFF0C\u5141\u8BB8\u7B49\u5F85 Env \u7EC4\u88C5\u5B8C\u6210\u3002\n   */\n  readonly waitForReady?: boolean\n}\n\nconst tagIdOf = (tag: Context.Tag<any, any>): string =>\n  typeof (tag as any)?.id === 'string'\n    ? String((tag as any).id)\n    : typeof (tag as any)?.key === 'string'\n      ? String((tag as any).key)\n      : '<unknown tag>'\n\nconst makeMissingRootProviderError = (\n  tag: Context.Tag<any, any>,\n  entrypoint: RootResolveEntrypoint,\n  extra?: string,\n): Error => {\n  const dev = isDevEnv()\n  const tokenId = tagIdOf(tag)\n  const fix: string[] = dev\n    ? [\n        '- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).',\n        \"- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).\",\n        '- Do not rely on nested RuntimeProvider.layer to mock Root.resolve.',\n      ]\n    : []\n\n  const message = dev\n    ? [\n        '[MissingRootProviderError] Cannot resolve Tag from root provider.',\n        extra ? `\\n${extra}` : '',\n        `tokenId: ${tokenId}`,\n        `entrypoint: ${entrypoint}`,\n        'mode: global',\n        'startScope: root',\n        '',\n        'fix:',\n        ...fix,\n      ]\n        .filter((s) => s.length > 0)\n        .join('\\n')\n    : '[MissingRootProviderError] tag not found in root provider'\n\n  const err = new Error(message)\n  err.name = 'MissingRootProviderError'\n  ;(err as any).tokenId = tokenId\n  ;(err as any).entrypoint = entrypoint\n  ;(err as any).mode = 'global'\n  ;(err as any).startScope = { kind: 'root' }\n  ;(err as any).fix = fix\n  return err\n}\n\n/**\n * resolve\n *\n * \u663E\u5F0F\u4ECE\u201C\u5F53\u524D Runtime Tree \u7684\u6839\uFF08root provider\uFF09\u201D\u89E3\u6790\u67D0\u4E2A Tag\uFF08ServiceTag / ModuleTag\uFF09\u3002\n *\n * \u8BED\u4E49\uFF1A\n * - \u56FA\u5B9A\u8BFB\u53D6 rootContext\uFF0C\u4E0D\u53D7\u66F4\u8FD1 scope \u7684 Layer/Context \u8986\u76D6\u5F71\u54CD\uFF1B\n * - \u5BF9 ModuleTag\uFF1A\u53EA\u8868\u8FBE root \u5355\u4F8B\u8BED\u4E49\uFF08\u4E0D\u7528\u4E8E\u591A\u5B9E\u4F8B\u9009\u62E9\uFF09\u3002\n */\nexport const resolve = <Id, Svc>(\n  tag: Context.Tag<Id, Svc>,\n  options?: RootResolveOptions,\n): Effect.Effect<Svc, never, any> =>\n  Effect.gen(function* () {\n    const entrypoint: RootResolveEntrypoint = options?.entrypoint ?? 'logic.root.resolve'\n\n    const root = yield* RootContextTag\n\n    const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : undefined)\n\n    if (!rootContext) {\n      return yield* Effect.die(\n        makeMissingRootProviderError(tag as Context.Tag<any, any>, entrypoint, 'reason: rootContextNotReady'),\n      )\n    }\n\n    try {\n      return Context.get(rootContext, tag as Context.Tag<any, any>) as Svc\n    } catch {\n      return yield* Effect.die(makeMissingRootProviderError(tag as Context.Tag<any, any>, entrypoint))\n    }\n  })\n\n/**\n * layerFromContext\uFF08tests/perf only\uFF09\n *\n * \u4E3A Root.resolve \u63D0\u4F9B\u4E00\u4E2A\u201C\u53EF\u7ACB\u5373\u4F7F\u7528\u201D\u7684 RootContext\u3002\n * - ready \u4F1A\u88AB\u7ACB\u5373 fulfill\uFF0C\u907F\u514D waitForReady=true \u65F6\u4EA7\u751F\u989D\u5916\u7B49\u5F85\u3002\n */\nexport const layerFromContext = (context: Context.Context<any>): Layer.Layer<any, never, any> =>\n  Layer.scoped(\n    RootContextTag,\n    Effect.gen(function* () {\n      const ready = yield* Deferred.make<Context.Context<any>>()\n      yield* Deferred.succeed(ready, context)\n      const root: RootContext = { context, ready }\n      return root\n    }),\n  )\n", "import { Context, Deferred } from 'effect'\n\nexport interface RootContext {\n  context: Context.Context<any> | undefined\n  readonly ready: Deferred.Deferred<Context.Context<any>, never>\n  readonly appId?: string\n  readonly appModuleIds?: ReadonlyArray<string>\n}\n\nclass RootContextTagImpl extends Context.Tag('@logix/core/RootContext')<RootContextTagImpl, RootContext>() {}\n\nexport const RootContextTag = RootContextTagImpl\n"],
  "mappings": ";;;;;;;AAAA,SAAS,WAAAA,UAAS,YAAAC,WAAU,QAAQ,aAAa;;;ACAjD,SAAS,eAAyB;AASlC,IAAM,qBAAN,cAAiC,QAAQ,IAAI,yBAAyB,EAAmC,EAAE;AAAC;AAErG,IAAM,iBAAiB;;;ADK9B,IAAM,UAAU,CAAC,QACf,OAAQ,KAAa,OAAO,WACxB,OAAQ,IAAY,EAAE,IACtB,OAAQ,KAAa,QAAQ,WAC3B,OAAQ,IAAY,GAAG,IACvB;AAER,IAAM,+BAA+B,CACnC,KACA,YACA,UACU;AACV,QAAM,MAAM,SAAS;AACrB,QAAM,UAAU,QAAQ,GAAG;AAC3B,QAAM,MAAgB,MAClB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,EACF,IACA,CAAC;AAEL,QAAM,UAAU,MACZ;AAAA,IACE;AAAA,IACA,QAAQ;AAAA,EAAK,KAAK,KAAK;AAAA,IACvB,YAAY,OAAO;AAAA,IACnB,eAAe,UAAU;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,EACG,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1B,KAAK,IAAI,IACZ;AAEJ,QAAM,MAAM,IAAI,MAAM,OAAO;AAC7B,MAAI,OAAO;AACV,EAAC,IAAY,UAAU;AACvB,EAAC,IAAY,aAAa;AAC1B,EAAC,IAAY,OAAO;AACpB,EAAC,IAAY,aAAa,EAAE,MAAM,OAAO;AACzC,EAAC,IAAY,MAAM;AACpB,SAAO;AACT;AAWO,IAAM,UAAU,CACrB,KACA,YAEA,OAAO,IAAI,aAAa;AACtB,QAAM,aAAoC,SAAS,cAAc;AAEjE,QAAM,OAAO,OAAO;AAEpB,QAAM,cAAc,KAAK,YAAY,SAAS,eAAe,OAAO,KAAK,QAAQ;AAEjF,MAAI,CAAC,aAAa;AAChB,WAAO,OAAO,OAAO;AAAA,MACnB,6BAA6B,KAA8B,YAAY,6BAA6B;AAAA,IACtG;AAAA,EACF;AAEA,MAAI;AACF,WAAOC,SAAQ,IAAI,aAAa,GAA4B;AAAA,EAC9D,QAAQ;AACN,WAAO,OAAO,OAAO,IAAI,6BAA6B,KAA8B,UAAU,CAAC;AAAA,EACjG;AACF,CAAC;AAQI,IAAM,mBAAmB,CAAC,YAC/B,MAAM;AAAA,EACJ;AAAA,EACA,OAAO,IAAI,aAAa;AACtB,UAAM,QAAQ,OAAOC,UAAS,KAA2B;AACzD,WAAOA,UAAS,QAAQ,OAAO,OAAO;AACtC,UAAM,OAAoB,EAAE,SAAS,MAAM;AAC3C,WAAO;AAAA,EACT,CAAC;AACH;",
  "names": ["Context", "Deferred", "Context", "Deferred"]
}
