@zag-js/core 1.34.1 → 1.35.0

package/dist/merge-props.js

@@ -0,0 +1,80 @@
+"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/merge-props.ts
+var merge_props_exports = {};
+__export(merge_props_exports, {
+  mergeProps: () => mergeProps
+});
+module.exports = __toCommonJS(merge_props_exports);
+var import_utils = require("@zag-js/utils");
+var clsx = (...args) => args.map((str) => str?.trim?.()).filter(Boolean).join(" ");
+var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+var serialize = (style) => {
+  const res = {};
+  let match;
+  while (match = CSS_REGEX.exec(style)) {
+    res[match[1]] = match[2];
+  }
+  return res;
+};
+var css = (a, b) => {
+  if ((0, import_utils.isString)(a)) {
+    if ((0, import_utils.isString)(b)) return `${a};${b}`;
+    a = serialize(a);
+  } else if ((0, import_utils.isString)(b)) {
+    b = serialize(b);
+  }
+  return Object.assign({}, a ?? {}, b ?? {});
+};
+function mergeProps(...args) {
+  let result = {};
+  for (let props of args) {
+    if (!props) continue;
+    for (let key in result) {
+      if (key.startsWith("on") && typeof result[key] === "function" && typeof props[key] === "function") {
+        result[key] = (0, import_utils.callAll)(props[key], result[key]);
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        result[key] = clsx(result[key], props[key]);
+        continue;
+      }
+      if (key === "style") {
+        result[key] = css(result[key], props[key]);
+        continue;
+      }
+      result[key] = props[key] !== void 0 ? props[key] : result[key];
+    }
+    for (let key in props) {
+      if (result[key] === void 0) {
+        result[key] = props[key];
+      }
+    }
+    const symbols = Object.getOwnPropertySymbols(props);
+    for (let symbol of symbols) {
+      result[symbol] = props[symbol];
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeProps
+});

package/dist/merge-props.mjs

@@ -0,0 +1,55 @@
+// src/merge-props.ts
+import { callAll, isString } from "@zag-js/utils";
+var clsx = (...args) => args.map((str) => str?.trim?.()).filter(Boolean).join(" ");
+var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+var serialize = (style) => {
+  const res = {};
+  let match;
+  while (match = CSS_REGEX.exec(style)) {
+    res[match[1]] = match[2];
+  }
+  return res;
+};
+var css = (a, b) => {
+  if (isString(a)) {
+    if (isString(b)) return `${a};${b}`;
+    a = serialize(a);
+  } else if (isString(b)) {
+    b = serialize(b);
+  }
+  return Object.assign({}, a ?? {}, b ?? {});
+};
+function mergeProps(...args) {
+  let result = {};
+  for (let props of args) {
+    if (!props) continue;
+    for (let key in result) {
+      if (key.startsWith("on") && typeof result[key] === "function" && typeof props[key] === "function") {
+        result[key] = callAll(props[key], result[key]);
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        result[key] = clsx(result[key], props[key]);
+        continue;
+      }
+      if (key === "style") {
+        result[key] = css(result[key], props[key]);
+        continue;
+      }
+      result[key] = props[key] !== void 0 ? props[key] : result[key];
+    }
+    for (let key in props) {
+      if (result[key] === void 0) {
+        result[key] = props[key];
+      }
+    }
+    const symbols = Object.getOwnPropertySymbols(props);
+    for (let symbol of symbols) {
+      result[symbol] = props[symbol];
+    }
+  }
+  return result;
+}
+export {
+  mergeProps
+};

package/dist/scope.d.mts

@@ -0,0 +1,15 @@
+import { isActiveElement } from '@zag-js/dom-query';
+import { Scope } from './types.mjs';
+
+declare function createScope(props: Pick<Scope, "id" | "ids" | "getRootNode">): {
+    getRootNode: () => Document | ShadowRoot;
+    getDoc: () => Document;
+    getWin: () => Window & typeof globalThis;
+    getActiveElement: () => HTMLElement | null;
+    isActiveElement: typeof isActiveElement;
+    getById: <T extends Element = HTMLElement>(id: string) => T | null;
+    id?: string | undefined | undefined;
+    ids?: Record<string, any> | undefined;
+};
+
+export { createScope };

package/dist/scope.d.ts

@@ -0,0 +1,15 @@
+import { isActiveElement } from '@zag-js/dom-query';
+import { Scope } from './types.js';
+
+declare function createScope(props: Pick<Scope, "id" | "ids" | "getRootNode">): {
+    getRootNode: () => Document | ShadowRoot;
+    getDoc: () => Document;
+    getWin: () => Window & typeof globalThis;
+    getActiveElement: () => HTMLElement | null;
+    isActiveElement: typeof isActiveElement;
+    getById: <T extends Element = HTMLElement>(id: string) => T | null;
+    id?: string | undefined | undefined;
+    ids?: Record<string, any> | undefined;
+};
+
+export { createScope };

package/dist/scope.js

@@ -0,0 +1,46 @@
+"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/scope.ts
+var scope_exports = {};
+__export(scope_exports, {
+  createScope: () => createScope
+});
+module.exports = __toCommonJS(scope_exports);
+var import_dom_query = require("@zag-js/dom-query");
+function createScope(props) {
+  const getRootNode = () => props.getRootNode?.() ?? document;
+  const getDoc = () => (0, import_dom_query.getDocument)(getRootNode());
+  const getWin = () => getDoc().defaultView ?? window;
+  const getActiveElementFn = () => (0, import_dom_query.getActiveElement)(getRootNode());
+  const getById = (id) => getRootNode().getElementById(id);
+  return {
+    ...props,
+    getRootNode,
+    getDoc,
+    getWin,
+    getActiveElement: getActiveElementFn,
+    isActiveElement: import_dom_query.isActiveElement,
+    getById
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createScope
+});

package/dist/scope.mjs

@@ -0,0 +1,21 @@
+// src/scope.ts
+import { getActiveElement, getDocument, isActiveElement } from "@zag-js/dom-query";
+function createScope(props) {
+  const getRootNode = () => props.getRootNode?.() ?? document;
+  const getDoc = () => getDocument(getRootNode());
+  const getWin = () => getDoc().defaultView ?? window;
+  const getActiveElementFn = () => getActiveElement(getRootNode());
+  const getById = (id) => getRootNode().getElementById(id);
+  return {
+    ...props,
+    getRootNode,
+    getDoc,
+    getWin,
+    getActiveElement: getActiveElementFn,
+    isActiveElement,
+    getById
+  };
+}
+export {
+  createScope
+};

package/dist/state.d.mts

@@ -0,0 +1,25 @@
+import { MachineSchema, Machine, MachineState, TransitionMatch } from './types.mjs';
+
+declare function ensureStateIndex<T extends MachineSchema>(machine: Machine<T>): Map<string, MachineState<T, string>>;
+type StateChain<T extends MachineSchema> = Array<{
+    path: string;
+    state: MachineState<T>;
+}>;
+declare function getStateChain<T extends MachineSchema>(machine: Machine<T>, state: T["state"] | undefined): StateChain<T>;
+declare function resolveStateValue<T extends MachineSchema>(machine: Machine<T>, value: T["state"] | string, source?: string): T["state"];
+declare function getStateDefinition<T extends MachineSchema>(machine: Machine<T>, state: T["state"]): MachineState<T, string>;
+declare function findTransition<T extends MachineSchema>(machine: Machine<T>, state: T["state"], eventType: string): TransitionMatch<T>;
+declare function getExitEnterStates<T extends MachineSchema>(machine: Machine<T>, prevState: T["state"] | undefined, nextState: T["state"], reenter?: boolean): {
+    exiting: {
+        path: string;
+        state: MachineState<T, string>;
+    }[];
+    entering: {
+        path: string;
+        state: MachineState<T, string>;
+    }[];
+};
+declare function matchesState(current: string | undefined, value: string): boolean;
+declare function hasTag<T extends MachineSchema>(machine: Machine<T>, state: T["state"], tag: T["tag"]): boolean;
+
+export { ensureStateIndex, findTransition, getExitEnterStates, getStateChain, getStateDefinition, hasTag, matchesState, resolveStateValue };

package/dist/state.d.ts

@@ -0,0 +1,25 @@
+import { MachineSchema, Machine, MachineState, TransitionMatch } from './types.js';
+
+declare function ensureStateIndex<T extends MachineSchema>(machine: Machine<T>): Map<string, MachineState<T, string>>;
+type StateChain<T extends MachineSchema> = Array<{
+    path: string;
+    state: MachineState<T>;
+}>;
+declare function getStateChain<T extends MachineSchema>(machine: Machine<T>, state: T["state"] | undefined): StateChain<T>;
+declare function resolveStateValue<T extends MachineSchema>(machine: Machine<T>, value: T["state"] | string, source?: string): T["state"];
+declare function getStateDefinition<T extends MachineSchema>(machine: Machine<T>, state: T["state"]): MachineState<T, string>;
+declare function findTransition<T extends MachineSchema>(machine: Machine<T>, state: T["state"], eventType: string): TransitionMatch<T>;
+declare function getExitEnterStates<T extends MachineSchema>(machine: Machine<T>, prevState: T["state"] | undefined, nextState: T["state"], reenter?: boolean): {
+    exiting: {
+        path: string;
+        state: MachineState<T, string>;
+    }[];
+    entering: {
+        path: string;
+        state: MachineState<T, string>;
+    }[];
+};
+declare function matchesState(current: string | undefined, value: string): boolean;
+declare function hasTag<T extends MachineSchema>(machine: Machine<T>, state: T["state"], tag: T["tag"]): boolean;
+
+export { ensureStateIndex, findTransition, getExitEnterStates, getStateChain, getStateDefinition, hasTag, matchesState, resolveStateValue };

package/dist/state.js

@@ -0,0 +1,172 @@
+"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/state.ts
+var state_exports = {};
+__export(state_exports, {
+  ensureStateIndex: () => ensureStateIndex,
+  findTransition: () => findTransition,
+  getExitEnterStates: () => getExitEnterStates,
+  getStateChain: () => getStateChain,
+  getStateDefinition: () => getStateDefinition,
+  hasTag: () => hasTag,
+  matchesState: () => matchesState,
+  resolveStateValue: () => resolveStateValue
+});
+module.exports = __toCommonJS(state_exports);
+var STATE_DELIMITER = ".";
+var stateIndexCache = /* @__PURE__ */ new WeakMap();
+function joinStatePath(parts) {
+  return parts.join(STATE_DELIMITER);
+}
+function isAbsoluteStatePath(value) {
+  return value.includes(STATE_DELIMITER);
+}
+function appendStatePath(base, segment) {
+  return base ? `${base}${STATE_DELIMITER}${segment}` : segment;
+}
+function buildStateIndex(machine) {
+  const index = /* @__PURE__ */ new Map();
+  const visit = (basePath, state) => {
+    index.set(basePath, state);
+    const childStates = state.states;
+    if (!childStates) return;
+    for (const [childKey, childState] of Object.entries(childStates)) {
+      if (!childState) continue;
+      const childPath = appendStatePath(basePath, childKey);
+      visit(childPath, childState);
+    }
+  };
+  for (const [topKey, topState] of Object.entries(machine.states)) {
+    if (!topState) continue;
+    visit(topKey, topState);
+  }
+  return index;
+}
+function ensureStateIndex(machine) {
+  const cached = stateIndexCache.get(machine);
+  if (cached) return cached;
+  const index = buildStateIndex(machine);
+  stateIndexCache.set(machine, index);
+  return index;
+}
+function toSegments(value) {
+  if (!value) return [];
+  return String(value).split(STATE_DELIMITER).filter(Boolean);
+}
+function getStateChain(machine, state) {
+  if (!state) return [];
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(state);
+  const chain = [];
+  const statePath = [];
+  for (const segment of segments) {
+    statePath.push(segment);
+    const path = joinStatePath(statePath);
+    const current = stateIndex.get(path);
+    if (!current) break;
+    chain.push({ path, state: current });
+  }
+  return chain;
+}
+function resolveAbsoluteStateValue(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(value);
+  if (!segments.length) return value;
+  const resolved = [];
+  for (const segment of segments) {
+    resolved.push(segment);
+    const path = joinStatePath(resolved);
+    if (!stateIndex.has(path)) return value;
+  }
+  let resolvedPath = joinStatePath(resolved);
+  let current = stateIndex.get(resolvedPath);
+  while (current?.initial) {
+    const nextPath = `${resolvedPath}${STATE_DELIMITER}${current.initial}`;
+    const nextState = stateIndex.get(nextPath);
+    if (!nextState) break;
+    resolvedPath = nextPath;
+    current = nextState;
+  }
+  return resolvedPath;
+}
+function hasStatePath(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  return stateIndex.has(value);
+}
+function resolveStateValue(machine, value, source) {
+  const stateValue = String(value);
+  if (!isAbsoluteStatePath(stateValue) && source) {
+    const sourceSegments = toSegments(source);
+    for (let index = sourceSegments.length; index >= 1; index--) {
+      const base = sourceSegments.slice(0, index).join(STATE_DELIMITER);
+      const candidate = appendStatePath(base, stateValue);
+      if (hasStatePath(machine, candidate)) return resolveAbsoluteStateValue(machine, candidate);
+    }
+  }
+  return resolveAbsoluteStateValue(machine, stateValue);
+}
+function getStateDefinition(machine, state) {
+  const chain = getStateChain(machine, state);
+  return chain[chain.length - 1]?.state;
+}
+function findTransition(machine, state, eventType) {
+  const chain = getStateChain(machine, state);
+  for (let index = chain.length - 1; index >= 0; index--) {
+    const transitionMap = chain[index]?.state.on;
+    const transition = transitionMap?.[eventType];
+    if (transition) return { transitions: transition, source: chain[index]?.path };
+  }
+  const rootTransitionMap = machine.on;
+  return { transitions: rootTransitionMap?.[eventType], source: void 0 };
+}
+function getExitEnterStates(machine, prevState, nextState, reenter) {
+  const prevChain = prevState ? getStateChain(machine, prevState) : [];
+  const nextChain = getStateChain(machine, nextState);
+  let commonIndex = 0;
+  while (commonIndex < prevChain.length && commonIndex < nextChain.length && prevChain[commonIndex]?.path === nextChain[commonIndex]?.path) {
+    commonIndex += 1;
+  }
+  let exiting = prevChain.slice(commonIndex).reverse();
+  let entering = nextChain.slice(commonIndex);
+  const sameLeaf = prevChain.at(-1)?.path === nextChain.at(-1)?.path;
+  if (reenter && sameLeaf) {
+    exiting = prevChain.slice().reverse();
+    entering = nextChain;
+  }
+  return { exiting, entering };
+}
+function matchesState(current, value) {
+  if (!current) return false;
+  return current === value || current.startsWith(`${value}${STATE_DELIMITER}`);
+}
+function hasTag(machine, state, tag) {
+  return getStateChain(machine, state).some((item) => item.state.tags?.includes(tag));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureStateIndex,
+  findTransition,
+  getExitEnterStates,
+  getStateChain,
+  getStateDefinition,
+  hasTag,
+  matchesState,
+  resolveStateValue
+});

package/dist/state.mjs

@@ -0,0 +1,140 @@
+// src/state.ts
+var STATE_DELIMITER = ".";
+var stateIndexCache = /* @__PURE__ */ new WeakMap();
+function joinStatePath(parts) {
+  return parts.join(STATE_DELIMITER);
+}
+function isAbsoluteStatePath(value) {
+  return value.includes(STATE_DELIMITER);
+}
+function appendStatePath(base, segment) {
+  return base ? `${base}${STATE_DELIMITER}${segment}` : segment;
+}
+function buildStateIndex(machine) {
+  const index = /* @__PURE__ */ new Map();
+  const visit = (basePath, state) => {
+    index.set(basePath, state);
+    const childStates = state.states;
+    if (!childStates) return;
+    for (const [childKey, childState] of Object.entries(childStates)) {
+      if (!childState) continue;
+      const childPath = appendStatePath(basePath, childKey);
+      visit(childPath, childState);
+    }
+  };
+  for (const [topKey, topState] of Object.entries(machine.states)) {
+    if (!topState) continue;
+    visit(topKey, topState);
+  }
+  return index;
+}
+function ensureStateIndex(machine) {
+  const cached = stateIndexCache.get(machine);
+  if (cached) return cached;
+  const index = buildStateIndex(machine);
+  stateIndexCache.set(machine, index);
+  return index;
+}
+function toSegments(value) {
+  if (!value) return [];
+  return String(value).split(STATE_DELIMITER).filter(Boolean);
+}
+function getStateChain(machine, state) {
+  if (!state) return [];
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(state);
+  const chain = [];
+  const statePath = [];
+  for (const segment of segments) {
+    statePath.push(segment);
+    const path = joinStatePath(statePath);
+    const current = stateIndex.get(path);
+    if (!current) break;
+    chain.push({ path, state: current });
+  }
+  return chain;
+}
+function resolveAbsoluteStateValue(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(value);
+  if (!segments.length) return value;
+  const resolved = [];
+  for (const segment of segments) {
+    resolved.push(segment);
+    const path = joinStatePath(resolved);
+    if (!stateIndex.has(path)) return value;
+  }
+  let resolvedPath = joinStatePath(resolved);
+  let current = stateIndex.get(resolvedPath);
+  while (current?.initial) {
+    const nextPath = `${resolvedPath}${STATE_DELIMITER}${current.initial}`;
+    const nextState = stateIndex.get(nextPath);
+    if (!nextState) break;
+    resolvedPath = nextPath;
+    current = nextState;
+  }
+  return resolvedPath;
+}
+function hasStatePath(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  return stateIndex.has(value);
+}
+function resolveStateValue(machine, value, source) {
+  const stateValue = String(value);
+  if (!isAbsoluteStatePath(stateValue) && source) {
+    const sourceSegments = toSegments(source);
+    for (let index = sourceSegments.length; index >= 1; index--) {
+      const base = sourceSegments.slice(0, index).join(STATE_DELIMITER);
+      const candidate = appendStatePath(base, stateValue);
+      if (hasStatePath(machine, candidate)) return resolveAbsoluteStateValue(machine, candidate);
+    }
+  }
+  return resolveAbsoluteStateValue(machine, stateValue);
+}
+function getStateDefinition(machine, state) {
+  const chain = getStateChain(machine, state);
+  return chain[chain.length - 1]?.state;
+}
+function findTransition(machine, state, eventType) {
+  const chain = getStateChain(machine, state);
+  for (let index = chain.length - 1; index >= 0; index--) {
+    const transitionMap = chain[index]?.state.on;
+    const transition = transitionMap?.[eventType];
+    if (transition) return { transitions: transition, source: chain[index]?.path };
+  }
+  const rootTransitionMap = machine.on;
+  return { transitions: rootTransitionMap?.[eventType], source: void 0 };
+}
+function getExitEnterStates(machine, prevState, nextState, reenter) {
+  const prevChain = prevState ? getStateChain(machine, prevState) : [];
+  const nextChain = getStateChain(machine, nextState);
+  let commonIndex = 0;
+  while (commonIndex < prevChain.length && commonIndex < nextChain.length && prevChain[commonIndex]?.path === nextChain[commonIndex]?.path) {
+    commonIndex += 1;
+  }
+  let exiting = prevChain.slice(commonIndex).reverse();
+  let entering = nextChain.slice(commonIndex);
+  const sameLeaf = prevChain.at(-1)?.path === nextChain.at(-1)?.path;
+  if (reenter && sameLeaf) {
+    exiting = prevChain.slice().reverse();
+    entering = nextChain;
+  }
+  return { exiting, entering };
+}
+function matchesState(current, value) {
+  if (!current) return false;
+  return current === value || current.startsWith(`${value}${STATE_DELIMITER}`);
+}
+function hasTag(machine, state, tag) {
+  return getStateChain(machine, state).some((item) => item.state.tags?.includes(tag));
+}
+export {
+  ensureStateIndex,
+  findTransition,
+  getExitEnterStates,
+  getStateChain,
+  getStateDefinition,
+  hasTag,
+  matchesState,
+  resolveStateValue
+};