@logixjs/core 0.0.1

package/dist/TraitLifecycle.cjs

@@ -0,0 +1,581 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TraitLifecycle.ts
+var TraitLifecycle_exports = {};
+__export(TraitLifecycle_exports, {
+  Ref: () => Ref3,
+  cleanup: () => cleanup2,
+  install: () => install2,
+  makeSourceWiring: () => makeSourceWiring2,
+  scopedExecute: () => scopedExecute2,
+  scopedValidate: () => scopedValidate2
+});
+module.exports = __toCommonJS(TraitLifecycle_exports);
+
+// src/internal/trait-lifecycle/index.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect5 = require("effect");
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect3 = require("effect");
+
+// src/internal/observability/jsonValue.ts
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect = require("effect");
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect2 = require("effect");
+var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect3.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect3.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect3.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect3.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect3.Effect.logError(message).pipe(
+    import_effect3.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect3.Effect.logWarning(msg) : event.severity === "info" ? import_effect3.Effect.logInfo(msg) : import_effect3.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect3.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void
+};
+var errorOnlyLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect3.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect3.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect3.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Logger.replace(
+  import_effect3.Logger.defaultLogger,
+  import_effect3.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+
+// src/internal/runtime/core/env.ts
+var import_effect4 = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = import_effect5.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect5.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/ReplayLog.ts
+var import_effect6 = require("effect");
+var ReplayLog = class extends import_effect6.Context.Tag("@logixjs/core/ReplayLog")() {
+};
+var snapshot = import_effect6.Effect.gen(function* () {
+  const log = yield* ReplayLog;
+  return yield* log.snapshot;
+});
+var resetCursor = import_effect6.Effect.gen(function* () {
+  const log = yield* ReplayLog;
+  yield* log.resetCursor;
+});
+
+// src/internal/state-trait/rowid.ts
+var parseSegments = (path) => {
+  if (!path) return [];
+  return path.split(".").map((seg) => /^[0-9]+$/.test(seg) ? Number(seg) : seg);
+};
+var unsetAtPathMutating = (draft, path) => {
+  if (!path) return;
+  const segments = parseSegments(path);
+  if (segments.length === 0) return;
+  let current = draft;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const key = segments[i];
+    const next = current?.[key];
+    if (next == null || typeof next !== "object") {
+      return;
+    }
+    current = next;
+  }
+  const last = segments[segments.length - 1];
+  if (Array.isArray(current) && typeof last === "number") {
+    current[last] = void 0;
+    return;
+  }
+  if (current && typeof current === "object") {
+    delete current[last];
+  }
+};
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/boundInternals");
+var MODULE_TRAITS_PROGRAM = /* @__PURE__ */ Symbol.for("@logixjs/core/moduleTraitsProgram");
+var getModuleTraitsProgram = (module2) => {
+  if (!module2) return void 0;
+  if (typeof module2 !== "object" && typeof module2 !== "function") return void 0;
+  return module2[MODULE_TRAITS_PROGRAM];
+};
+var getBoundInternals = (bound) => {
+  const internals = bound[BOUND_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingBoundInternals] Bound internals not installed on Bound API instance.",
+      "fix:",
+      "- Ensure BoundApiRuntime attaches internals (020 foundation).",
+      "- If you created a mock bound for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Bound internals not installed";
+    throw new Error(msg);
+  }
+  return internals;
+};
+
+// src/internal/trait-lifecycle/index.ts
+var Ref2 = {
+  field: (path) => ({ kind: "field", path }),
+  list: (path, listIndexPath) => ({
+    kind: "list",
+    path,
+    listIndexPath
+  }),
+  item: (path, index, options) => ({
+    kind: "item",
+    path,
+    index,
+    listIndexPath: options?.listIndexPath,
+    field: options?.field
+  }),
+  /**
+   * fromValuePath：
+   * - Parse a valuePath (e.g. "items.0.warehouseId") into a FieldRef.
+   * - Supports a single index (required) and multi-level indices via listIndexPath (optional but recommended).
+   *
+   * Conventions:
+   * - If numeric segments are present, return an item ref (the last index becomes item.index; preceding indices go into listIndexPath).
+   * - If no numeric segments are present:
+   *   - "items[]" (pattern list root) returns a list ref.
+   *   - Otherwise return a field ref (including pattern fields like "items[].x").
+   * - "$root" / empty string returns the root ref.
+   */
+  fromValuePath: (valuePath) => {
+    const raw = typeof valuePath === "string" ? valuePath.trim() : "";
+    if (!raw || raw === "$root") return Ref2.root();
+    const segments = raw.split(".").filter(Boolean);
+    if (segments.length === 0) return Ref2.root();
+    const isIndex = (seg) => /^[0-9]+$/.test(seg);
+    const stripPattern = (seg) => seg.endsWith("[]") ? seg.slice(0, -2) : seg;
+    const indexPositions = [];
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (!isIndex(seg)) continue;
+      const index = Number(seg);
+      if (!Number.isFinite(index) || index < 0) return Ref2.field(raw);
+      indexPositions.push({ pos: i, index });
+    }
+    if (indexPositions.length > 0) {
+      const last = indexPositions[indexPositions.length - 1];
+      const listIndexPath = indexPositions.slice(0, -1).map((p) => p.index);
+      const listPath = segments.slice(0, last.pos).filter((seg) => !isIndex(seg)).map(stripPattern).join(".");
+      if (!listPath) return Ref2.field(raw);
+      const fieldRest = segments.slice(last.pos + 1).map(stripPattern).join(".");
+      return Ref2.item(listPath, last.index, {
+        listIndexPath: listIndexPath.length > 0 ? listIndexPath : void 0,
+        field: fieldRest ? fieldRest : void 0
+      });
+    }
+    if (segments.some((s) => s.includes("[]"))) {
+      const last = segments[segments.length - 1];
+      if (last.endsWith("[]")) {
+        return Ref2.list(segments.map(stripPattern).join("."));
+      }
+    }
+    return Ref2.field(raw);
+  },
+  root: () => ({ kind: "root" })
+};
+var scopedValidate = (bound, request) => import_effect7.Effect.gen(function* () {
+  let internals;
+  try {
+    internals = getBoundInternals(bound);
+  } catch {
+    return;
+  }
+  const enqueue = internals.traits.enqueueStateTraitValidateRequest;
+  if (!enqueue) return;
+  const toTarget = (ref) => {
+    if (ref.kind === "root") return { kind: "root" };
+    if (ref.kind === "field") return { kind: "field", path: ref.path };
+    if (ref.kind === "list") {
+      return {
+        kind: "list",
+        path: ref.path,
+        ...ref.listIndexPath ? { listIndexPath: ref.listIndexPath } : {}
+      };
+    }
+    return {
+      kind: "item",
+      path: ref.path,
+      index: ref.index,
+      ...ref.listIndexPath ? { listIndexPath: ref.listIndexPath } : {},
+      field: ref.field
+    };
+  };
+  const internal = {
+    mode: request.mode,
+    target: toTarget(request.target)
+  };
+  const inTxn = yield* import_effect7.FiberRef.get(inSyncTransactionFiber);
+  if (inTxn) {
+    enqueue(internal);
+    return;
+  }
+  yield* internals.txn.runWithStateTransaction(
+    { kind: "trait", name: "scopedValidate", details: request },
+    () => import_effect7.Effect.sync(() => {
+      enqueue(internal);
+    })
+  );
+});
+var scopedExecute = (bound, request) => import_effect7.Effect.gen(function* () {
+  if (request.kind === "source:refresh") {
+    const toFieldPath = (ref) => {
+      if (ref.kind === "root") return void 0;
+      if (ref.kind === "field" || ref.kind === "list") return ref.path;
+      const base = `${ref.path}[]`;
+      return ref.field ? `${base}.${ref.field}` : base;
+    };
+    const fieldPath = toFieldPath(request.target);
+    if (!fieldPath) {
+      return;
+    }
+    yield* bound.traits.source.refresh(fieldPath);
+    return;
+  }
+  if (request.kind !== "query:invalidate") {
+    return;
+  }
+  const replayLogOpt = yield* import_effect7.Effect.serviceOption(ReplayLog);
+  if (import_effect7.Option.isNone(replayLogOpt)) {
+    return;
+  }
+  let moduleId;
+  let instanceId;
+  try {
+    const internals = getBoundInternals(bound);
+    moduleId = internals.moduleId;
+    instanceId = internals.instanceId;
+  } catch {
+    moduleId = void 0;
+    instanceId = void 0;
+  }
+  yield* replayLogOpt.value.record({
+    _tag: "InvalidateRequest",
+    timestamp: Date.now(),
+    moduleId,
+    instanceId,
+    kind: "query",
+    target: "query",
+    meta: request.request
+  });
+});
+var cleanup = (bound, request) => import_effect7.Effect.gen(function* () {
+  const apply = () => bound.state.mutate((draft) => {
+    const clearAt = (root, path) => {
+      if (!path) return;
+      unsetAtPathMutating(draft, `${root}.${path}`);
+    };
+    if (request.kind === "field:unregister") {
+      const target = request.target;
+      if (target.kind !== "field") return;
+      clearAt("errors", target.path);
+      clearAt("ui", target.path);
+      return;
+    }
+    if (request.kind === "list:item:remove") {
+      const target = request.target;
+      if (target.kind !== "item") return;
+      const base = `${target.path}.${target.index}`;
+      const path = target.field ? `${base}.${target.field}` : base;
+      clearAt("errors", path);
+      clearAt("ui", path);
+      return;
+    }
+    if (request.kind === "list:reorder") {
+      return;
+    }
+  });
+  const inTxn = yield* import_effect7.FiberRef.get(inSyncTransactionFiber);
+  if (inTxn) {
+    return yield* apply();
+  }
+  let runWithTxn;
+  try {
+    const internals = getBoundInternals(bound);
+    runWithTxn = (origin, body) => internals.txn.runWithStateTransaction(origin, body);
+  } catch {
+    runWithTxn = void 0;
+  }
+  if (!runWithTxn) {
+    return yield* apply();
+  }
+  return yield* runWithTxn({ kind: "trait", name: "cleanup", details: request }, apply);
+});
+var isAuxRootPath = (path) => path === "errors" || path === "ui" || path.startsWith("errors.") || path.startsWith("ui.");
+var toPatternPath = (path) => {
+  if (!path) return path;
+  const segments = path.split(".").filter(Boolean);
+  return segments.map((seg) => /^[0-9]+$/.test(seg) ? "[]" : seg).join(".").replace(/\.\[\]/g, "[]");
+};
+var isDepAffectedByChange = (dep, changed) => {
+  if (!dep || !changed) return false;
+  if (dep === changed) return true;
+  if (changed.startsWith(`${dep}.`)) return true;
+  if (changed.startsWith(`${dep}[]`)) return true;
+  if (dep.startsWith(`${changed}[]`)) return true;
+  return false;
+};
+var makeSourceWiring = (bound, module2) => {
+  const program = getModuleTraitsProgram(module2);
+  const sources = program?.entries?.filter((e) => e && e.kind === "source") ?? [];
+  const sourceOnMount = sources.filter(
+    (e) => Array.isArray(e?.meta?.triggers) ? e.meta.triggers.includes("onMount") : false
+  );
+  const sourceOnKeyChange = sources.filter(
+    (e) => Array.isArray(e?.meta?.triggers) ? e.meta.triggers.includes("onKeyChange") : false
+  );
+  const setup = import_effect7.Effect.sync(() => {
+    if (sourceOnMount.length === 0) return;
+    bound.lifecycle.onStart(
+      import_effect7.Effect.forEach(sourceOnMount, (entry) => bound.traits.source.refresh(entry.fieldPath), {
+        concurrency: "unbounded"
+      }).pipe(import_effect7.Effect.asVoid)
+    );
+  });
+  const refreshOnKeyChange = (changedPath) => import_effect7.Effect.gen(function* () {
+    if (!changedPath || isAuxRootPath(changedPath)) return;
+    if (sourceOnKeyChange.length === 0) return;
+    const changedPattern = toPatternPath(changedPath);
+    yield* import_effect7.Effect.forEach(
+      sourceOnKeyChange,
+      (entry) => {
+        const deps = entry?.meta?.deps ?? [];
+        const affected = deps.some((dep) => isDepAffectedByChange(dep, changedPattern));
+        if (!affected) return import_effect7.Effect.void;
+        return bound.traits.source.refresh(entry.fieldPath);
+      },
+      { concurrency: "unbounded" }
+    );
+  }).pipe(import_effect7.Effect.asVoid);
+  return { setup, refreshOnKeyChange };
+};
+var install = (_bound) => import_effect7.Effect.void;
+
+// src/TraitLifecycle.ts
+var Ref3 = Ref2;
+var scopedValidate2 = (bound, request) => scopedValidate(bound, request);
+var scopedExecute2 = (bound, request) => scopedExecute(bound, request);
+var cleanup2 = (bound, request) => cleanup(bound, request);
+var makeSourceWiring2 = (bound, module2) => makeSourceWiring(bound, module2);
+var install2 = (bound) => install(bound);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Ref,
+  cleanup,
+  install,
+  makeSourceWiring,
+  scopedExecute,
+  scopedValidate
+});
+//# sourceMappingURL=TraitLifecycle.cjs.map