@fluixi/reactive 1.0.0-alpha.100

package/dist/lib/signal/graph/observe.mjs

@@ -0,0 +1,175 @@
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function withReactiveOrigin(owner, fn) {
+  if (!G.observer) return fn();
+  const previous = origin;
+  origin = owner;
+  try {
+    return fn();
+  } finally {
+    origin = previous;
+  }
+}
+var currentScope;
+function openReactiveScope(info) {
+  const scope = {};
+  G.observer?.scope?.(scope, info, currentScope);
+  return scope;
+}
+function withReactiveScope(scope, fn) {
+  if (!G.observer) return fn();
+  const previous = currentScope;
+  currentScope = scope;
+  try {
+    return fn();
+  } finally {
+    currentScope = previous;
+  }
+}
+function closeReactiveScope(scope) {
+  G.observer?.scopeEnded?.(scope);
+}
+function adoptReactiveScope(scope, parent) {
+  G.observer?.scopeAdopted?.(scope, parent);
+}
+var SCOPE_OF = /* @__PURE__ */ Symbol.for("fluixi.reactiveScope");
+function markReactiveScope(value, scope) {
+  Object.defineProperty(value, SCOPE_OF, { value: scope, configurable: true, enumerable: false });
+}
+function reactiveScopeOf(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") ? value[SCOPE_OF] ?? void 0 : void 0;
+}
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin, scope: report.scope ?? currentScope } : { ...report, scope: report.scope ?? currentScope }
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveBinding(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.bound || !running.length) return;
+  observer.bound(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveProps(props) {
+  const observer = G.observer;
+  if (!observer?.props || !running.length || !props) return;
+  observer.props(running[running.length - 1], props);
+}
+function reportReactiveDirective(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.directive || !running.length) return;
+  observer.directive(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveContextCreated(id) {
+  G.observer?.contextCreated?.(id);
+}
+function reportReactiveContext(id, kind, value) {
+  const observer = G.observer;
+  if (!observer?.context || !running.length) return;
+  observer.context(running[running.length - 1], id, kind, value);
+}
+function reportReactiveMove(node, origin2, name) {
+  G.observer?.moved?.(node, origin2, name);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+export {
+  adoptReactiveScope,
+  closeReactiveScope,
+  enterReactiveRun,
+  exitReactiveRun,
+  isObserved,
+  markReactiveScope,
+  observeReactiveNodes,
+  openReactiveScope,
+  reactiveScopeOf,
+  reportReactiveBinding,
+  reportReactiveContext,
+  reportReactiveContextCreated,
+  reportReactiveDirective,
+  reportReactiveDispose,
+  reportReactiveMove,
+  reportReactiveNode,
+  reportReactiveProps,
+  reportReactiveRun,
+  reportReactiveWrite,
+  withReactiveOrigin,
+  withReactiveScope
+};