@player-ui/context-plugin 0.16.0--canary.891.38194

package/dist/cjs/index.cjs

@@ -0,0 +1,621 @@
+"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);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ContextPlugin: () => ContextPlugin,
+  ContextPluginSymbol: () => ContextPluginSymbol,
+  StateContextPlugin: () => StateContextPlugin,
+  dataContextKey: () => dataContextKey,
+  defineContextKey: () => defineContextKey,
+  flowIdContextKey: () => flowIdContextKey,
+  flowStateContextKey: () => flowStateContextKey,
+  getContextPlugin: () => getContextPlugin,
+  nameOfContextKey: () => nameOfContextKey,
+  playerStateContextKey: () => playerStateContextKey,
+  playerStatusContextKey: () => playerStatusContextKey,
+  resolveContextKeySymbol: () => resolveContextKeySymbol,
+  setDataActionKey: () => setDataActionKey,
+  transitionActionKey: () => transitionActionKey,
+  validationContextKey: () => validationContextKey,
+  viewContextKey: () => viewContextKey,
+  viewIdContextKey: () => viewIdContextKey
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/plugin.ts
+var import_tapable_ts = require("tapable-ts");
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/key.ts
+var KEY_NAMESPACE = "player-ui.context.";
+var defineContextKey = (name, description) => ({
+  symbol: Symbol.for(`${KEY_NAMESPACE}${name}`),
+  description
+});
+var resolveContextKeySymbol = (name) => Symbol.for(`${KEY_NAMESPACE}${name}`);
+var nameOfContextKey = (key) => {
+  const k = Symbol.keyFor(key.symbol);
+  if (!k || !k.startsWith(KEY_NAMESPACE))
+    return void 0;
+  return k.slice(KEY_NAMESPACE.length);
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/store.ts
+var deepFreezeEntry = (entry) => {
+  Object.freeze(entry);
+  return entry;
+};
+var tombstone = (description) => () => {
+  throw new Error(
+    `[ContextPlugin] Action "${description}" is no longer valid \u2014 its flow has ended`
+  );
+};
+var tombstoneFunctions = (value, description) => {
+  if (typeof value === "function") {
+    return tombstone(description);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => tombstoneFunctions(item, description));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = tombstoneFunctions(v, description);
+    }
+    return out;
+  }
+  return value;
+};
+var ContextStore = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    /** source symbol -> set of target symbols (reverse index for invalidation). */
+    this.dependents = /* @__PURE__ */ new Map();
+  }
+  register(key) {
+    if (this.entries.has(key.symbol)) {
+      return false;
+    }
+    this.entries.set(key.symbol, { key, hasLiteral: false });
+    return true;
+  }
+  set(key, value) {
+    const existing = this.entries.get(key.symbol);
+    if (existing) {
+      existing.hasLiteral = true;
+      existing.literal = value;
+      existing.key = key;
+    } else {
+      this.entries.set(key.symbol, {
+        key,
+        hasLiteral: true,
+        literal: value
+      });
+    }
+  }
+  registerTransform(key, transform) {
+    const existing = this.entries.get(key.symbol);
+    const previousSources = existing?.transform?.sources;
+    if (previousSources) {
+      for (const src of previousSources) {
+        this.dependents.get(src.symbol)?.delete(key.symbol);
+      }
+    }
+    const stored = {
+      sources: transform.sources,
+      compute: transform.compute
+    };
+    if (existing) {
+      existing.transform = stored;
+      existing.key = key;
+    } else {
+      this.entries.set(key.symbol, {
+        key,
+        hasLiteral: false,
+        transform: stored
+      });
+    }
+    for (const src of transform.sources) {
+      let set = this.dependents.get(src.symbol);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.dependents.set(src.symbol, set);
+      }
+      set.add(key.symbol);
+    }
+    return { previousSources };
+  }
+  get(key) {
+    return this.compute(key.symbol);
+  }
+  has(key) {
+    const entry = this.entries.get(key.symbol);
+    return Boolean(entry && (entry.hasLiteral || entry.transform));
+  }
+  /** Return the keys that depend on the given source key (direct dependents only). */
+  dependentsOf(sourceSymbol) {
+    const set = this.dependents.get(sourceSymbol);
+    if (!set || set.size === 0) {
+      return [];
+    }
+    const out = [];
+    for (const targetSymbol of set) {
+      const target = this.entries.get(targetSymbol);
+      if (target) {
+        out.push(target.key);
+      }
+    }
+    return out;
+  }
+  list() {
+    const out = [];
+    for (const entry of this.entries.values()) {
+      out.push({
+        symbol: entry.key.symbol,
+        description: entry.key.description,
+        hasValue: entry.hasLiteral,
+        hasTransform: Boolean(entry.transform)
+      });
+    }
+    return out;
+  }
+  freeze(meta) {
+    const frozenEntries = [];
+    for (const entry of this.entries.values()) {
+      if (!entry.hasLiteral && !entry.transform) {
+        continue;
+      }
+      const computed = this.compute(entry.key.symbol);
+      const value = tombstoneFunctions(computed, entry.key.description);
+      frozenEntries.push(
+        deepFreezeEntry({
+          symbol: entry.key.symbol,
+          name: nameOfContextKey(entry.key),
+          description: entry.key.description,
+          value
+        })
+      );
+    }
+    const bySymbol = new Map(frozenEntries.map((e) => [e.symbol, e.value]));
+    const snapshot = {
+      flowId: meta.flowId,
+      endedAt: meta.endedAt,
+      entries: Object.freeze(frozenEntries),
+      get(key) {
+        return bySymbol.get(key.symbol);
+      }
+    };
+    return Object.freeze(snapshot);
+  }
+  compute(sym) {
+    const entry = this.entries.get(sym);
+    if (!entry)
+      return void 0;
+    if (entry.hasLiteral)
+      return entry.literal;
+    if (!entry.transform)
+      return void 0;
+    const reader = (otherKey) => this.compute(otherKey.symbol);
+    return entry.transform.compute(reader);
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/history.ts
+var ContextHistory = class {
+  constructor() {
+    this.stack = [];
+  }
+  push(snapshot) {
+    this.stack.push(snapshot);
+  }
+  entries() {
+    return this.stack;
+  }
+  size() {
+    return this.stack.length;
+  }
+  clear() {
+    this.stack = [];
+  }
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/symbols.ts
+var ContextPluginSymbol = Symbol.for("ContextPlugin");
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/plugin.ts
+var subscriptionCounter = 0;
+var _ContextPlugin = class _ContextPlugin {
+  constructor() {
+    this.name = "context";
+    this.symbol = _ContextPlugin.Symbol;
+    this.hooks = {
+      onSet: new import_tapable_ts.SyncHook(),
+      resolveValue: new import_tapable_ts.SyncWaterfallHook(),
+      onRegister: new import_tapable_ts.SyncHook(),
+      onFlowFrozen: new import_tapable_ts.SyncHook()
+    };
+    this.transforms = /* @__PURE__ */ new Map();
+    this.perKeySubs = /* @__PURE__ */ new Map();
+    this.globalSubs = /* @__PURE__ */ new Map();
+    this.tokenIndex = /* @__PURE__ */ new Map();
+    this.store = new ContextStore();
+    this.historyStack = new ContextHistory();
+  }
+  apply(player) {
+    const existing = player.findPlugin(ContextPluginSymbol);
+    if (existing !== void 0 && existing !== this) {
+      this.store = existing.store;
+      this.historyStack = existing.historyStack;
+      this.transforms = existing.transforms;
+      this.perKeySubs = existing.perKeySubs;
+      this.globalSubs = existing.globalSubs;
+      this.tokenIndex = existing.tokenIndex;
+      return;
+    }
+    player.hooks.onStart.tap(this.name, (flow) => {
+      this.currentFlowId = flow?.id;
+    });
+    player.hooks.onEnd.tap(this.name, () => {
+      const snapshot = this.store.freeze({
+        flowId: this.currentFlowId,
+        endedAt: Date.now()
+      });
+      this.historyStack.push(snapshot);
+      this.hooks.onFlowFrozen.call(snapshot);
+      this.rotateStore();
+      this.currentFlowId = void 0;
+    });
+  }
+  register(key) {
+    const added = this.store.register(key);
+    if (added) {
+      this.hooks.onRegister.call(key);
+    }
+  }
+  set(key, value) {
+    const isFirstSighting = !this.store.has(key);
+    this.store.set(key, value);
+    if (isFirstSighting) {
+      this.hooks.onRegister.call(key);
+    }
+    this.notify(key, value);
+    const dependents = this.store.dependentsOf(key.symbol);
+    for (const dep of dependents) {
+      const computed = this.store.get(dep);
+      this.notify(dep, computed);
+    }
+  }
+  get(key) {
+    const raw = this.store.get(key);
+    const resolved = this.hooks.resolveValue.call(raw, key);
+    return resolved;
+  }
+  has(key) {
+    return this.store.has(key);
+  }
+  registerTransform(key, transform) {
+    const isFirstSighting = !this.store.has(key);
+    this.store.registerTransform(key, transform);
+    this.transforms.set(key.symbol, {
+      key,
+      transform: {
+        sources: transform.sources,
+        compute: transform.compute
+      }
+    });
+    if (isFirstSighting) {
+      this.hooks.onRegister.call(key);
+    }
+  }
+  subscribe(key, handler) {
+    const token = this.nextToken();
+    let bucket = this.perKeySubs.get(key.symbol);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      this.perKeySubs.set(key.symbol, bucket);
+    }
+    bucket.set(token, handler);
+    this.tokenIndex.set(token, key.symbol);
+    return token;
+  }
+  subscribeAll(handler) {
+    const token = this.nextToken();
+    this.globalSubs.set(token, handler);
+    this.tokenIndex.set(token, void 0);
+    return token;
+  }
+  unsubscribe(token) {
+    const owner = this.tokenIndex.get(token);
+    if (owner === void 0) {
+      this.globalSubs.delete(token);
+    } else {
+      this.perKeySubs.get(owner)?.delete(token);
+    }
+    this.tokenIndex.delete(token);
+  }
+  list() {
+    return this.store.list();
+  }
+  history() {
+    return this.historyStack.entries();
+  }
+  snapshot() {
+    return this.store.freeze({
+      flowId: this.currentFlowId,
+      endedAt: Date.now()
+    });
+  }
+  /**
+   * Bridge-friendly: set a value by string name. Used by native wrappers that
+   * cannot construct a `ContextKey` object directly.
+   */
+  setByName(name, description, value) {
+    this.set(this.ensureNamedKey(name, description), value);
+  }
+  /** Bridge-friendly: get a value by string name. */
+  getByName(name) {
+    return this.get(this.ensureNamedKey(name));
+  }
+  /** Bridge-friendly: check presence by string name. */
+  hasByName(name) {
+    return this.has(this.ensureNamedKey(name));
+  }
+  /** Bridge-friendly: subscribe by string name. */
+  subscribeByName(name, description, handler) {
+    return this.subscribe(
+      this.ensureNamedKey(name, description),
+      (value) => handler(value, name)
+    );
+  }
+  /**
+   * Bridge-friendly: subscribe to all updates. The handler receives the
+   * key's resolved name (or undefined for non-namespaced keys).
+   */
+  subscribeAllByName(handler) {
+    return this.subscribeAll(
+      (value, key) => handler(value, nameOfContextKey(key), key.description)
+    );
+  }
+  ensureNamedKey(name, description) {
+    return defineContextKey(name, description ?? name);
+  }
+  notify(key, value) {
+    this.hooks.onSet.call(key, value);
+    const bucket = this.perKeySubs.get(key.symbol);
+    if (bucket) {
+      for (const handler of bucket.values()) {
+        handler(value, key);
+      }
+    }
+    for (const handler of this.globalSubs.values()) {
+      handler(value, key);
+    }
+  }
+  rotateStore() {
+    this.store = new ContextStore();
+    for (const { key, transform } of this.transforms.values()) {
+      this.store.registerTransform(key, transform);
+    }
+  }
+  nextToken() {
+    subscriptionCounter += 1;
+    return `ctx_${subscriptionCounter}`;
+  }
+};
+_ContextPlugin.Symbol = ContextPluginSymbol;
+var ContextPlugin = _ContextPlugin;
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/utils.ts
+function getContextPlugin(player) {
+  const existing = player.findPlugin(ContextPluginSymbol);
+  const plugin = existing ?? new ContextPlugin();
+  if (!existing) {
+    player.registerPlugin(plugin);
+  }
+  return plugin;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/context/core/src/state-plugin.ts
+var flowIdContextKey = defineContextKey(
+  "player.flow.id",
+  "Identifier of the running flow"
+);
+var flowStateContextKey = defineContextKey(
+  "player.flow.state",
+  "Name of the current FSM state in the running flow"
+);
+var viewIdContextKey = defineContextKey(
+  "player.view.id",
+  "Identifier of the currently-resolved view"
+);
+var viewContextKey = defineContextKey(
+  "player.view",
+  "Full resolved view object for the current FSM state"
+);
+var dataContextKey = defineContextKey(
+  "player.data",
+  "Full data model tree for the running flow"
+);
+var playerStatusContextKey = defineContextKey(
+  "player.status",
+  "Player flow status: not-started, in-progress, completed, or error"
+);
+var validationContextKey = defineContextKey(
+  "player.validation",
+  "Validation state for the running view, keyed by binding"
+);
+var setDataActionKey = defineContextKey(
+  "player.data.set",
+  "Set a value in the Player data model at the given binding"
+);
+var transitionActionKey = defineContextKey(
+  "player.flow.transition",
+  "Transition the current flow using the given transition value"
+);
+var playerStateContextKey = defineContextKey(
+  "player.state",
+  "Aggregated snapshot of every Player runtime context entry"
+);
+var StateContextPlugin = class {
+  constructor() {
+    this.name = "state-context";
+  }
+  apply(player) {
+    const ctx = getContextPlugin(player);
+    let validationController;
+    const publishValidation = () => {
+      if (!validationController)
+        return;
+      const byBinding = {};
+      let canTransition = true;
+      validationController.getBindings().forEach((binding) => {
+        const all = validationController.getValidationForBinding(binding)?.getAll() ?? [];
+        if (all.length === 0)
+          return;
+        byBinding[binding.asString()] = all.map((v) => ({
+          severity: v.severity,
+          message: v.message,
+          displayTarget: v.displayTarget,
+          blocking: v.blocking
+        }));
+        if (all.some((v) => v.blocking)) {
+          canTransition = false;
+        }
+      });
+      ctx.set(validationContextKey, { canTransition, byBinding });
+    };
+    ctx.register(flowIdContextKey);
+    ctx.register(flowStateContextKey);
+    ctx.register(viewIdContextKey);
+    ctx.register(viewContextKey);
+    ctx.register(dataContextKey);
+    ctx.register(playerStatusContextKey);
+    ctx.register(validationContextKey);
+    ctx.register(setDataActionKey);
+    ctx.register(transitionActionKey);
+    ctx.registerTransform(playerStateContextKey, {
+      sources: [
+        flowIdContextKey,
+        flowStateContextKey,
+        viewIdContextKey,
+        viewContextKey,
+        dataContextKey,
+        playerStatusContextKey,
+        validationContextKey,
+        setDataActionKey,
+        transitionActionKey
+      ],
+      compute: (read) => ({
+        status: read(playerStatusContextKey),
+        flow: {
+          id: read(flowIdContextKey),
+          state: read(flowStateContextKey),
+          transition: read(transitionActionKey)
+        },
+        view: {
+          id: read(viewIdContextKey),
+          resolved: read(viewContextKey)
+        },
+        data: {
+          model: read(dataContextKey),
+          set: read(setDataActionKey)
+        },
+        validation: read(validationContextKey) ?? {
+          canTransition: true,
+          byBinding: {}
+        }
+      })
+    });
+    player.hooks.onStart.tap(this.name, (flow) => {
+      if (flow?.id) {
+        ctx.set(flowIdContextKey, flow.id);
+      }
+    });
+    player.hooks.state.tap(this.name, (state) => {
+      ctx.set(playerStatusContextKey, state.status);
+    });
+    player.hooks.flowController.tap(this.name, (flowController) => {
+      const transition = (value) => flowController.transition(value);
+      ctx.set(transitionActionKey, transition);
+      flowController.hooks.flow.tap(this.name, (flowInstance) => {
+        const recordState = () => {
+          const name = flowInstance.currentState?.name;
+          if (name) {
+            ctx.set(flowStateContextKey, name);
+          }
+        };
+        recordState();
+        flowInstance.hooks.afterTransition.tap(this.name, recordState);
+      });
+    });
+    player.hooks.validationController.tap(this.name, (vc) => {
+      validationController = vc;
+      publishValidation();
+    });
+    player.hooks.viewController.tap(this.name, (viewController) => {
+      viewController.hooks.view.tap(this.name, (view) => {
+        const id = view.initialView?.id;
+        if (id) {
+          ctx.set(viewIdContextKey, id);
+        }
+        view.hooks.onUpdate.tap(this.name, (resolved) => {
+          ctx.set(viewContextKey, resolved);
+          if (resolved?.id) {
+            ctx.set(viewIdContextKey, resolved.id);
+          }
+          publishValidation();
+        });
+      });
+    });
+    player.hooks.dataController.tap(this.name, (dataController) => {
+      const setData = (binding, value) => {
+        dataController.set([[binding, value]]);
+      };
+      ctx.set(setDataActionKey, setData);
+      const publish = () => {
+        ctx.set(dataContextKey, dataController.serialize());
+        publishValidation();
+      };
+      dataController.hooks.onUpdate.tap(this.name, publish);
+      publish();
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextPlugin,
+  ContextPluginSymbol,
+  StateContextPlugin,
+  dataContextKey,
+  defineContextKey,
+  flowIdContextKey,
+  flowStateContextKey,
+  getContextPlugin,
+  nameOfContextKey,
+  playerStateContextKey,
+  playerStatusContextKey,
+  resolveContextKeySymbol,
+  setDataActionKey,
+  transitionActionKey,
+  validationContextKey,
+  viewContextKey,
+  viewIdContextKey
+});
+//# sourceMappingURL=index.cjs.map