@sprawlify/primitives 0.1.6 → 0.1.8

package/dist/core-Bw_czdwX.cjs

@@ -0,0 +1,383 @@
+const require_dom_query = require("./dom-query-BUO7rGsg.cjs");
+const require_utils = require("./utils-ByNiZU8f.cjs");
+//#region src/shared/core/merge-props.ts
+const clsx = (...args) => args.map((str) => str?.trim?.()).filter(Boolean).join(" ");
+const CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+const serialize = (style) => {
+	const res = {};
+	let match;
+	while (match = CSS_REGEX.exec(style)) res[match[1]] = match[2];
+	return res;
+};
+const css = (a, b) => {
+	if (require_utils.isString(a)) {
+		if (require_utils.isString(b)) return `${a};${b}`;
+		a = serialize(a);
+	} else if (require_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] = require_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;
+}
+//#endregion
+//#region src/shared/core/memo.ts
+function memo(getDeps, fn, opts) {
+	let deps = [];
+	let result;
+	return (depArgs) => {
+		const newDeps = getDeps(depArgs);
+		if (!(newDeps.length !== deps.length || newDeps.some((dep, index) => !require_utils.isEqual(deps[index], dep)))) return result;
+		deps = newDeps;
+		result = fn(newDeps, depArgs);
+		opts?.onChange?.(result);
+		return result;
+	};
+}
+//#endregion
+//#region src/shared/core/state.ts
+const STATE_DELIMITER = ".";
+const ABSOLUTE_PREFIX = "#";
+const stateIndexCache = /* @__PURE__ */ new WeakMap();
+const stateIdIndexCache = /* @__PURE__ */ new WeakMap();
+function joinStatePath(parts) {
+	return parts.join(STATE_DELIMITER);
+}
+function isAbsoluteStatePath(value) {
+	return value.includes(STATE_DELIMITER);
+}
+function isExplicitAbsoluteStatePath(value) {
+	return value.startsWith(ABSOLUTE_PREFIX);
+}
+function stripAbsolutePrefix(value) {
+	return isExplicitAbsoluteStatePath(value) ? value.slice(1) : value;
+}
+function appendStatePath(base, segment) {
+	return base ? `${base}${STATE_DELIMITER}${segment}` : segment;
+}
+function buildStateIndex(machine) {
+	const index = /* @__PURE__ */ new Map();
+	const idIndex = /* @__PURE__ */ new Map();
+	const visit = (basePath, state) => {
+		index.set(basePath, state);
+		const stateId = state.id;
+		if (stateId) {
+			if (idIndex.has(stateId)) throw new Error(`Duplicate state id: ${stateId}`);
+			idIndex.set(stateId, basePath);
+		}
+		const childStates = state.states;
+		if (!childStates) return;
+		for (const [childKey, childState] of Object.entries(childStates)) {
+			if (!childState) continue;
+			visit(appendStatePath(basePath, childKey), childState);
+		}
+	};
+	for (const [topKey, topState] of Object.entries(machine.states)) {
+		if (!topState) continue;
+		visit(topKey, topState);
+	}
+	return {
+		index,
+		idIndex
+	};
+}
+function ensureStateIndex(machine) {
+	const cached = stateIndexCache.get(machine);
+	if (cached) return cached;
+	const { index, idIndex } = buildStateIndex(machine);
+	stateIndexCache.set(machine, index);
+	stateIdIndexCache.set(machine, idIndex);
+	return index;
+}
+function getStatePathById(machine, stateId) {
+	ensureStateIndex(machine);
+	return stateIdIndexCache.get(machine)?.get(stateId);
+}
+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) {
+	return ensureStateIndex(machine).has(value);
+}
+function resolveStateValue(machine, value, source) {
+	const stateValue = String(value);
+	if (isExplicitAbsoluteStatePath(stateValue)) {
+		const stateId = stripAbsolutePrefix(stateValue);
+		const statePath = getStatePathById(machine, stateId);
+		if (!statePath) throw new Error(`Unknown state id: ${stateId}`);
+		return resolveAbsoluteStateValue(machine, statePath);
+	}
+	if (!isAbsoluteStatePath(stateValue) && source) {
+		const sourceSegments = toSegments(source);
+		for (let index = sourceSegments.length; index >= 1; index--) {
+			const candidate = appendStatePath(sourceSegments.slice(0, index).join(STATE_DELIMITER), 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 transition = (chain[index]?.state.on)?.[eventType];
+		if (transition) return {
+			transitions: transition,
+			source: chain[index]?.path
+		};
+	}
+	return {
+		transitions: machine.on?.[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));
+}
+//#endregion
+//#region src/shared/core/create-machine.ts
+function createGuards() {
+	return {
+		and: (...guards) => {
+			return function andGuard(params) {
+				return guards.every((str) => params.guard(str));
+			};
+		},
+		or: (...guards) => {
+			return function orGuard(params) {
+				return guards.some((str) => params.guard(str));
+			};
+		},
+		not: (guard) => {
+			return function notGuard(params) {
+				return !params.guard(guard);
+			};
+		}
+	};
+}
+function createMachine(config) {
+	ensureStateIndex(config);
+	return config;
+}
+function setup() {
+	return {
+		guards: createGuards(),
+		createMachine: (config) => {
+			return createMachine(config);
+		},
+		choose: (transitions) => {
+			return function chooseFn({ choose }) {
+				return choose(transitions)?.actions;
+			};
+		}
+	};
+}
+//#endregion
+//#region src/shared/core/types.ts
+let MachineStatus = /* @__PURE__ */ function(MachineStatus) {
+	MachineStatus["NotStarted"] = "Not Started";
+	MachineStatus["Started"] = "Started";
+	MachineStatus["Stopped"] = "Stopped";
+	return MachineStatus;
+}({});
+const INIT_STATE = "__init__";
+//#endregion
+//#region src/shared/core/scope.ts
+function createScope(props) {
+	const getRootNode = () => props.getRootNode?.() ?? document;
+	const getDoc = () => require_dom_query.getDocument(getRootNode());
+	const getWin = () => getDoc().defaultView ?? window;
+	const getActiveElementFn = () => require_dom_query.getActiveElement(getRootNode());
+	const getById = (id) => getRootNode().getElementById(id);
+	return {
+		...props,
+		getRootNode,
+		getDoc,
+		getWin,
+		getActiveElement: getActiveElementFn,
+		isActiveElement: require_dom_query.isActiveElement,
+		getById
+	};
+}
+//#endregion
+Object.defineProperty(exports, "INIT_STATE", {
+	enumerable: true,
+	get: function() {
+		return INIT_STATE;
+	}
+});
+Object.defineProperty(exports, "MachineStatus", {
+	enumerable: true,
+	get: function() {
+		return MachineStatus;
+	}
+});
+Object.defineProperty(exports, "createGuards", {
+	enumerable: true,
+	get: function() {
+		return createGuards;
+	}
+});
+Object.defineProperty(exports, "createMachine", {
+	enumerable: true,
+	get: function() {
+		return createMachine;
+	}
+});
+Object.defineProperty(exports, "createScope", {
+	enumerable: true,
+	get: function() {
+		return createScope;
+	}
+});
+Object.defineProperty(exports, "ensureStateIndex", {
+	enumerable: true,
+	get: function() {
+		return ensureStateIndex;
+	}
+});
+Object.defineProperty(exports, "findTransition", {
+	enumerable: true,
+	get: function() {
+		return findTransition;
+	}
+});
+Object.defineProperty(exports, "getExitEnterStates", {
+	enumerable: true,
+	get: function() {
+		return getExitEnterStates;
+	}
+});
+Object.defineProperty(exports, "getStateChain", {
+	enumerable: true,
+	get: function() {
+		return getStateChain;
+	}
+});
+Object.defineProperty(exports, "getStateDefinition", {
+	enumerable: true,
+	get: function() {
+		return getStateDefinition;
+	}
+});
+Object.defineProperty(exports, "hasTag", {
+	enumerable: true,
+	get: function() {
+		return hasTag;
+	}
+});
+Object.defineProperty(exports, "matchesState", {
+	enumerable: true,
+	get: function() {
+		return matchesState;
+	}
+});
+Object.defineProperty(exports, "memo", {
+	enumerable: true,
+	get: function() {
+		return memo;
+	}
+});
+Object.defineProperty(exports, "mergeProps", {
+	enumerable: true,
+	get: function() {
+		return mergeProps;
+	}
+});
+Object.defineProperty(exports, "resolveStateValue", {
+	enumerable: true,
+	get: function() {
+		return resolveStateValue;
+	}
+});
+Object.defineProperty(exports, "setup", {
+	enumerable: true,
+	get: function() {
+		return setup;
+	}
+});

package/dist/core-CTtbW9qh.mjs

@@ -0,0 +1,288 @@
+import { en as getActiveElement, sn as isActiveElement, tn as getDocument } from "./dom-query-BFuRs3l4.mjs";
+import { W as callAll, dt as isString, ft as isEqual } from "./utils-VVoZ_v29.mjs";
+//#region src/shared/core/merge-props.ts
+const clsx = (...args) => args.map((str) => str?.trim?.()).filter(Boolean).join(" ");
+const CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+const serialize = (style) => {
+	const res = {};
+	let match;
+	while (match = CSS_REGEX.exec(style)) res[match[1]] = match[2];
+	return res;
+};
+const 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;
+}
+//#endregion
+//#region src/shared/core/memo.ts
+function memo(getDeps, fn, opts) {
+	let deps = [];
+	let result;
+	return (depArgs) => {
+		const newDeps = getDeps(depArgs);
+		if (!(newDeps.length !== deps.length || newDeps.some((dep, index) => !isEqual(deps[index], dep)))) return result;
+		deps = newDeps;
+		result = fn(newDeps, depArgs);
+		opts?.onChange?.(result);
+		return result;
+	};
+}
+//#endregion
+//#region src/shared/core/state.ts
+const STATE_DELIMITER = ".";
+const ABSOLUTE_PREFIX = "#";
+const stateIndexCache = /* @__PURE__ */ new WeakMap();
+const stateIdIndexCache = /* @__PURE__ */ new WeakMap();
+function joinStatePath(parts) {
+	return parts.join(STATE_DELIMITER);
+}
+function isAbsoluteStatePath(value) {
+	return value.includes(STATE_DELIMITER);
+}
+function isExplicitAbsoluteStatePath(value) {
+	return value.startsWith(ABSOLUTE_PREFIX);
+}
+function stripAbsolutePrefix(value) {
+	return isExplicitAbsoluteStatePath(value) ? value.slice(1) : value;
+}
+function appendStatePath(base, segment) {
+	return base ? `${base}${STATE_DELIMITER}${segment}` : segment;
+}
+function buildStateIndex(machine) {
+	const index = /* @__PURE__ */ new Map();
+	const idIndex = /* @__PURE__ */ new Map();
+	const visit = (basePath, state) => {
+		index.set(basePath, state);
+		const stateId = state.id;
+		if (stateId) {
+			if (idIndex.has(stateId)) throw new Error(`Duplicate state id: ${stateId}`);
+			idIndex.set(stateId, basePath);
+		}
+		const childStates = state.states;
+		if (!childStates) return;
+		for (const [childKey, childState] of Object.entries(childStates)) {
+			if (!childState) continue;
+			visit(appendStatePath(basePath, childKey), childState);
+		}
+	};
+	for (const [topKey, topState] of Object.entries(machine.states)) {
+		if (!topState) continue;
+		visit(topKey, topState);
+	}
+	return {
+		index,
+		idIndex
+	};
+}
+function ensureStateIndex(machine) {
+	const cached = stateIndexCache.get(machine);
+	if (cached) return cached;
+	const { index, idIndex } = buildStateIndex(machine);
+	stateIndexCache.set(machine, index);
+	stateIdIndexCache.set(machine, idIndex);
+	return index;
+}
+function getStatePathById(machine, stateId) {
+	ensureStateIndex(machine);
+	return stateIdIndexCache.get(machine)?.get(stateId);
+}
+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) {
+	return ensureStateIndex(machine).has(value);
+}
+function resolveStateValue(machine, value, source) {
+	const stateValue = String(value);
+	if (isExplicitAbsoluteStatePath(stateValue)) {
+		const stateId = stripAbsolutePrefix(stateValue);
+		const statePath = getStatePathById(machine, stateId);
+		if (!statePath) throw new Error(`Unknown state id: ${stateId}`);
+		return resolveAbsoluteStateValue(machine, statePath);
+	}
+	if (!isAbsoluteStatePath(stateValue) && source) {
+		const sourceSegments = toSegments(source);
+		for (let index = sourceSegments.length; index >= 1; index--) {
+			const candidate = appendStatePath(sourceSegments.slice(0, index).join(STATE_DELIMITER), 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 transition = (chain[index]?.state.on)?.[eventType];
+		if (transition) return {
+			transitions: transition,
+			source: chain[index]?.path
+		};
+	}
+	return {
+		transitions: machine.on?.[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));
+}
+//#endregion
+//#region src/shared/core/create-machine.ts
+function createGuards() {
+	return {
+		and: (...guards) => {
+			return function andGuard(params) {
+				return guards.every((str) => params.guard(str));
+			};
+		},
+		or: (...guards) => {
+			return function orGuard(params) {
+				return guards.some((str) => params.guard(str));
+			};
+		},
+		not: (guard) => {
+			return function notGuard(params) {
+				return !params.guard(guard);
+			};
+		}
+	};
+}
+function createMachine(config) {
+	ensureStateIndex(config);
+	return config;
+}
+function setup() {
+	return {
+		guards: createGuards(),
+		createMachine: (config) => {
+			return createMachine(config);
+		},
+		choose: (transitions) => {
+			return function chooseFn({ choose }) {
+				return choose(transitions)?.actions;
+			};
+		}
+	};
+}
+//#endregion
+//#region src/shared/core/types.ts
+let MachineStatus = /* @__PURE__ */ function(MachineStatus) {
+	MachineStatus["NotStarted"] = "Not Started";
+	MachineStatus["Started"] = "Started";
+	MachineStatus["Stopped"] = "Stopped";
+	return MachineStatus;
+}({});
+const INIT_STATE = "__init__";
+//#endregion
+//#region src/shared/core/scope.ts
+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
+	};
+}
+//#endregion
+export { createMachine as a, findTransition as c, getStateDefinition as d, hasTag as f, mergeProps as g, memo as h, createGuards as i, getExitEnterStates as l, resolveStateValue as m, INIT_STATE as n, setup as o, matchesState as p, MachineStatus as r, ensureStateIndex as s, createScope as t, getStateChain as u };

package/dist/core.cjs

@@ -1,12 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./dom-query-BUO7rGsg.cjs");
 require("./utils-ByNiZU8f.cjs");
-const require_core = require("./core-DwdPztGA.cjs");
+const require_core = require("./core-Bw_czdwX.cjs");
 exports.INIT_STATE = require_core.INIT_STATE;
 exports.MachineStatus = require_core.MachineStatus;
 exports.createGuards = require_core.createGuards;
 exports.createMachine = require_core.createMachine;
 exports.createScope = require_core.createScope;
+exports.ensureStateIndex = require_core.ensureStateIndex;
+exports.findTransition = require_core.findTransition;
+exports.getExitEnterStates = require_core.getExitEnterStates;
+exports.getStateChain = require_core.getStateChain;
+exports.getStateDefinition = require_core.getStateDefinition;
+exports.hasTag = require_core.hasTag;
+exports.matchesState = require_core.matchesState;
 exports.memo = require_core.memo;
 exports.mergeProps = require_core.mergeProps;
+exports.resolveStateValue = require_core.resolveStateValue;
 exports.setup = require_core.setup;