@sprawlify/primitives 0.0.1

package/dist/utils-BZyrxWWR.mjs

@@ -0,0 +1,525 @@
+import { t as _defineProperty } from "./defineProperty-DrXfyjd4.mjs";
+
+//#region src/shared/utils/array.ts
+function toArray(v) {
+	if (v == null) return [];
+	return Array.isArray(v) ? v : [v];
+}
+const fromLength = (length) => Array.from(Array(length).keys());
+const first = (v) => v[0];
+const last = (v) => v[v.length - 1];
+const isEmpty = (v) => v.length === 0;
+const has = (v, t) => v.indexOf(t) !== -1;
+const add = (v, ...items) => v.concat(items);
+const remove = (v, ...items) => v.filter((t) => !items.includes(t));
+const removeAt = (v, i) => v.filter((_, idx) => idx !== i);
+const insertAt = (v, i, ...items) => [
+	...v.slice(0, i),
+	...items,
+	...v.slice(i)
+];
+const uniq = (v) => Array.from(new Set(v));
+const diff = (a, b) => {
+	const set = new Set(b);
+	return a.filter((t) => !set.has(t));
+};
+const addOrRemove = (v, item) => has(v, item) ? remove(v, item) : add(v, item);
+function clear(v) {
+	while (v.length > 0) v.pop();
+	return v;
+}
+function nextIndex(v, idx, opts = {}) {
+	const { step = 1, loop = true } = opts;
+	const next$1 = idx + step;
+	const len = v.length;
+	const last$1 = len - 1;
+	if (idx === -1) return step > 0 ? 0 : last$1;
+	if (next$1 < 0) return loop ? last$1 : 0;
+	if (next$1 >= len) return loop ? 0 : idx > len ? len : idx;
+	return next$1;
+}
+function next(v, idx, opts = {}) {
+	return v[nextIndex(v, idx, opts)];
+}
+function prevIndex(v, idx, opts = {}) {
+	const { step = 1, loop = true } = opts;
+	return nextIndex(v, idx, {
+		step: -step,
+		loop
+	});
+}
+function prev(v, index, opts = {}) {
+	return v[prevIndex(v, index, opts)];
+}
+function chunk(v, size) {
+	return v.reduce((rows, value, index) => {
+		if (index % size === 0) rows.push([value]);
+		else last(rows)?.push(value);
+		return rows;
+	}, []);
+}
+function flatArray(arr) {
+	return arr.reduce((flat, item) => {
+		if (Array.isArray(item)) return flat.concat(flatArray(item));
+		return flat.concat(item);
+	}, []);
+}
+function partition(arr, fn) {
+	return arr.reduce(([pass, fail], value) => {
+		if (fn(value)) pass.push(value);
+		else fail.push(value);
+		return [pass, fail];
+	}, [[], []]);
+}
+
+//#endregion
+//#region src/shared/utils/equal.ts
+const isArrayLike = (value) => value?.constructor.name === "Array";
+const isArrayEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i])) return false;
+	return true;
+};
+const isEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (a == null && b != null || a != null && b == null) return false;
+	if (typeof a?.isEqual === "function" && typeof b?.isEqual === "function") return a.isEqual(b);
+	if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+	if (isArrayLike(a) && isArrayLike(b)) return isArrayEqual(Array.from(a), Array.from(b));
+	if (!(typeof a === "object") || !(typeof b === "object")) return false;
+	const keys = Object.keys(b ?? Object.create(null));
+	const length = keys.length;
+	for (let i = 0; i < length; i++) if (!Reflect.has(a, keys[i])) return false;
+	for (let i = 0; i < length; i++) {
+		const key = keys[i];
+		if (!isEqual(a[key], b[key])) return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/shared/utils/guard.ts
+const isDev = () => process.env.NODE_ENV !== "production";
+const isArray = (v) => Array.isArray(v);
+const isBoolean = (v) => v === true || v === false;
+const isObjectLike = (v) => v != null && typeof v === "object";
+const isObject = (v) => isObjectLike(v) && !isArray(v);
+const isNumber = (v) => typeof v === "number" && !Number.isNaN(v);
+const isString = (v) => typeof v === "string";
+const isFunction = (v) => typeof v === "function";
+const isNull = (v) => v == null;
+const hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+const baseGetTag = (v) => Object.prototype.toString.call(v);
+const fnToString = Function.prototype.toString;
+const objectCtorString = fnToString.call(Object);
+const isPlainObject = (v) => {
+	if (!isObjectLike(v) || baseGetTag(v) != "[object Object]" || isFrameworkElement(v)) return false;
+	const proto = Object.getPrototypeOf(v);
+	if (proto === null) return true;
+	const Ctor = hasProp(proto, "constructor") && proto.constructor;
+	return typeof Ctor == "function" && Ctor instanceof Ctor && fnToString.call(Ctor) == objectCtorString;
+};
+const isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x && "props" in x;
+const isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+const isFrameworkElement = (x) => isReactElement(x) || isVueElement(x);
+
+//#endregion
+//#region src/shared/utils/functions.ts
+const runIfFn = (v, ...a) => {
+	return (typeof v === "function" ? v(...a) : v) ?? void 0;
+};
+const cast = (v) => v;
+const identity = (v) => v();
+const noop = () => {};
+const callAll = (...fns) => (...a) => {
+	fns.forEach(function(fn) {
+		fn?.(...a);
+	});
+};
+const uuid = (() => {
+	let id = 0;
+	return () => {
+		id++;
+		return id.toString(36);
+	};
+})();
+function match(key, record, ...args) {
+	if (key in record) {
+		const fn = record[key];
+		return isFunction(fn) ? fn(...args) : fn;
+	}
+	const error = /* @__PURE__ */ new Error(`No matching key: ${JSON.stringify(key)} in ${JSON.stringify(Object.keys(record))}`);
+	Error.captureStackTrace?.(error, match);
+	throw error;
+}
+const tryCatch = (fn, fallback) => {
+	try {
+		return fn();
+	} catch (error) {
+		if (error instanceof Error) Error.captureStackTrace?.(error, tryCatch);
+		return fallback?.();
+	}
+};
+function throttle(fn, wait = 0) {
+	let lastCall = 0;
+	let timeout = null;
+	return ((...args) => {
+		const now = Date.now();
+		const timeSinceLastCall = now - lastCall;
+		if (timeSinceLastCall >= wait) {
+			if (timeout) {
+				clearTimeout(timeout);
+				timeout = null;
+			}
+			fn(...args);
+			lastCall = now;
+		} else if (!timeout) timeout = setTimeout(() => {
+			fn(...args);
+			lastCall = Date.now();
+			timeout = null;
+		}, wait - timeSinceLastCall);
+	});
+}
+function debounce(fn, wait = 0) {
+	let timeout = null;
+	return ((...args) => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+		timeout = setTimeout(() => {
+			fn(...args);
+		}, wait);
+	});
+}
+
+//#endregion
+//#region src/shared/utils/number.ts
+const { floor, abs, round, min, max, pow, sign } = Math;
+const isNaN = (v) => Number.isNaN(v);
+const nan = (v) => isNaN(v) ? 0 : v;
+const mod = (v, m) => (v % m + m) % m;
+const wrap = (v, vmax) => (v % vmax + vmax) % vmax;
+const getMinValueAtIndex = (i, v, vmin) => i === 0 ? vmin : v[i - 1];
+const getMaxValueAtIndex = (i, v, vmax) => i === v.length - 1 ? vmax : v[i + 1];
+const isValueAtMax = (v, vmax) => nan(v) >= vmax;
+const isValueAtMin = (v, vmin) => nan(v) <= vmin;
+const isValueWithinRange = (v, vmin, vmax) => {
+	const value = nan(v);
+	return (vmin == null || value >= vmin) && (vmax == null || value <= vmax);
+};
+const roundValue = (v, vmin, step) => round((nan(v) - vmin) / step) * step + vmin;
+const clampValue = (v, vmin, vmax) => min(max(nan(v), vmin), vmax);
+const clampPercent = (v) => clampValue(v, 0, 1);
+const getValuePercent = (v, vmin, vmax) => (nan(v) - vmin) / (vmax - vmin);
+const getPercentValue = (p, vmin, vmax, step) => clampValue(roundValue(p * (vmax - vmin) + vmin, vmin, step), vmin, vmax);
+const roundToStepPrecision = (v, step) => {
+	let rv = v;
+	let ss = step.toString();
+	let pi = ss.indexOf(".");
+	let p = pi >= 0 ? ss.length - pi : 0;
+	if (p > 0) {
+		let pw = pow(10, p);
+		rv = round(rv * pw) / pw;
+	}
+	return rv;
+};
+const roundToDpr = (v, dpr) => typeof dpr === "number" ? floor(v * dpr + .5) / dpr : round(v);
+const snapValueToStep = (v, vmin, vmax, step) => {
+	const min$1 = vmin != null ? Number(vmin) : 0;
+	const max$1 = Number(vmax);
+	const remainder = (v - min$1) % step;
+	let snapped = abs(remainder) * 2 >= step ? v + sign(remainder) * (step - abs(remainder)) : v - remainder;
+	snapped = roundToStepPrecision(snapped, step);
+	if (!isNaN(min$1) && snapped < min$1) snapped = min$1;
+	else if (!isNaN(max$1) && snapped > max$1) {
+		const stepsInRange = floor((max$1 - min$1) / step);
+		const largestValidStep = min$1 + stepsInRange * step;
+		snapped = stepsInRange <= 0 || largestValidStep < min$1 ? max$1 : largestValidStep;
+	}
+	return roundToStepPrecision(snapped, step);
+};
+const setValueAtIndex = (vs, i, v) => {
+	if (vs[i] === v) return vs;
+	return [
+		...vs.slice(0, i),
+		v,
+		...vs.slice(i + 1)
+	];
+};
+function getValueSetterAtIndex(index, ctx) {
+	const minValueAtIndex = getMinValueAtIndex(index, ctx.values, ctx.min);
+	const maxValueAtIndex = getMaxValueAtIndex(index, ctx.values, ctx.max);
+	let nextValues = ctx.values.slice();
+	return function setValue(value) {
+		let nextValue = snapValueToStep(value, minValueAtIndex, maxValueAtIndex, ctx.step);
+		nextValues = setValueAtIndex(nextValues, index, value);
+		nextValues[index] = nextValue;
+		return nextValues;
+	};
+}
+function getNextStepValue(index, ctx) {
+	const nextValue = ctx.values[index] + ctx.step;
+	return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+function getPreviousStepValue(index, ctx) {
+	const nextValue = ctx.values[index] - ctx.step;
+	return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+const getClosestValueIndex = (vs, t) => {
+	let i = vs.findIndex((v) => t - v < 0);
+	if (i === 0) return i;
+	if (i === -1) return vs.length - 1;
+	let vLeft = vs[i - 1];
+	let vRight = vs[i];
+	if (abs(vLeft - t) < abs(vRight - t)) return i - 1;
+	return i;
+};
+const getClosestValue = (vs, t) => vs[getClosestValueIndex(vs, t)];
+const getValueRanges = (vs, vmin, vmax, gap) => vs.map((v, i) => ({
+	min: i === 0 ? vmin : vs[i - 1] + gap,
+	max: i === vs.length - 1 ? vmax : vs[i + 1] - gap,
+	value: v
+}));
+const getValueTransformer = (va, vb) => {
+	const [a, b] = va;
+	const [c, d] = vb;
+	return (v) => a === b || c === d ? c : c + (d - c) / (b - a) * (v - a);
+};
+const toFixedNumber = (v, d = 0, b = 10) => {
+	const pow$1 = Math.pow(b, d);
+	return round(v * pow$1) / pow$1;
+};
+const countDecimals = (value) => {
+	if (!Number.isFinite(value)) return 0;
+	let e = 1, p = 0;
+	while (Math.round(value * e) / e !== value) {
+		e *= 10;
+		p += 1;
+	}
+	return p;
+};
+const decimalOp = (a, op, b) => {
+	let result = op === "+" ? a + b : a - b;
+	if (a % 1 !== 0 || b % 1 !== 0) {
+		const multiplier = 10 ** Math.max(countDecimals(a), countDecimals(b));
+		a = Math.round(a * multiplier);
+		b = Math.round(b * multiplier);
+		result = op === "+" ? a + b : a - b;
+		result /= multiplier;
+	}
+	return result;
+};
+const incrementValue = (v, s) => decimalOp(nan(v), "+", s);
+const decrementValue = (v, s) => decimalOp(nan(v), "-", s);
+const toPx = (v) => typeof v === "number" ? `${v}px` : v;
+
+//#endregion
+//#region src/shared/utils/object.ts
+function compact(obj) {
+	if (!isPlainObject(obj) || obj === void 0) return obj;
+	const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+	const filtered = {};
+	for (const key of keys) {
+		const value = obj[key];
+		if (value !== void 0) filtered[key] = compact(value);
+	}
+	return filtered;
+}
+const json = (v) => JSON.parse(JSON.stringify(v));
+function pick(obj, keys) {
+	const filtered = {};
+	for (const key of keys) {
+		const value = obj[key];
+		if (value !== void 0) filtered[key] = value;
+	}
+	return filtered;
+}
+function splitProps(props, keys) {
+	const rest = {};
+	const result = {};
+	const keySet = new Set(keys);
+	const ownKeys = Reflect.ownKeys(props);
+	for (const key of ownKeys) if (keySet.has(key)) result[key] = props[key];
+	else rest[key] = props[key];
+	return [result, rest];
+}
+const createSplitProps = (keys) => {
+	return function split(props) {
+		return splitProps(props, keys);
+	};
+};
+function omit(obj, keys) {
+	return createSplitProps(keys)(obj)[1];
+}
+
+//#endregion
+//#region src/shared/utils/store.ts
+function createStore(initialState, compare = Object.is) {
+	let state = { ...initialState };
+	const listeners = /* @__PURE__ */ new Set();
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const publish = () => {
+		listeners.forEach((listener) => listener());
+	};
+	const get = (key) => {
+		return state[key];
+	};
+	const set = (key, value) => {
+		if (!compare(state[key], value)) {
+			state[key] = value;
+			publish();
+		}
+	};
+	const update = (updates) => {
+		let hasChanges = false;
+		for (const key in updates) {
+			const value = updates[key];
+			if (value !== void 0 && !compare(state[key], value)) {
+				state[key] = value;
+				hasChanges = true;
+			}
+		}
+		if (hasChanges) publish();
+	};
+	const snapshot = () => ({ ...state });
+	return {
+		subscribe,
+		get,
+		set,
+		update,
+		snapshot
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region src/shared/utils/timers.ts
+const currentTime = () => performance.now();
+var _tick = /* @__PURE__ */ new WeakMap();
+var Timer = class {
+	constructor(onTick) {
+		this.onTick = onTick;
+		_defineProperty(this, "frameId", null);
+		_defineProperty(this, "pausedAtMs", null);
+		_defineProperty(this, "context", void 0);
+		_defineProperty(this, "cancelFrame", () => {
+			if (this.frameId === null) return;
+			cancelAnimationFrame(this.frameId);
+			this.frameId = null;
+		});
+		_defineProperty(this, "setStartMs", (startMs) => {
+			this.context.startMs = startMs;
+		});
+		_defineProperty(this, "start", () => {
+			if (this.frameId !== null) return;
+			const now = currentTime();
+			if (this.pausedAtMs !== null) {
+				this.context.startMs += now - this.pausedAtMs;
+				this.pausedAtMs = null;
+			} else this.context.startMs = now;
+			this.frameId = requestAnimationFrame(_classPrivateFieldGet2(_tick, this));
+		});
+		_defineProperty(this, "pause", () => {
+			if (this.frameId === null) return;
+			this.cancelFrame();
+			this.pausedAtMs = currentTime();
+		});
+		_defineProperty(this, "stop", () => {
+			if (this.frameId === null) return;
+			this.cancelFrame();
+			this.pausedAtMs = null;
+		});
+		_classPrivateFieldInitSpec(this, _tick, (now) => {
+			this.context.now = now;
+			this.context.deltaMs = now - this.context.startMs;
+			if (this.onTick(this.context) === false) {
+				this.stop();
+				return;
+			}
+			this.frameId = requestAnimationFrame(_classPrivateFieldGet2(_tick, this));
+		});
+		this.context = {
+			now: 0,
+			startMs: currentTime(),
+			deltaMs: 0
+		};
+	}
+	get elapsedMs() {
+		if (this.pausedAtMs !== null) return this.pausedAtMs - this.context.startMs;
+		return currentTime() - this.context.startMs;
+	}
+};
+function setRafInterval(fn, intervalMs) {
+	const timer = new Timer(({ now, deltaMs }) => {
+		if (deltaMs >= intervalMs) {
+			const startMs = intervalMs > 0 ? now - deltaMs % intervalMs : now;
+			timer.setStartMs(startMs);
+			fn({
+				startMs,
+				deltaMs
+			});
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+function setRafTimeout(fn, delayMs) {
+	const timer = new Timer(({ deltaMs }) => {
+		if (deltaMs >= delayMs) {
+			fn();
+			return false;
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+
+//#endregion
+//#region src/shared/utils/warning.ts
+function warn(...a) {
+	const m = a.length === 1 ? a[0] : a[1];
+	if ((a.length === 2 ? a[0] : true) && process.env.NODE_ENV !== "production") console.warn(m);
+}
+function invariant(...a) {
+	const m = a.length === 1 ? a[0] : a[1];
+	if ((a.length === 2 ? a[0] : true) && process.env.NODE_ENV !== "production") throw new Error(m);
+}
+function ensure(c, m) {
+	if (c == null) throw new Error(m());
+}
+function ensureProps(props, keys, scope) {
+	let missingKeys = [];
+	for (const key of keys) if (props[key] == null) missingKeys.push(key);
+	if (missingKeys.length > 0) throw new Error(`[sprawlify-js${scope ? ` > ${scope}` : ""}] missing required props: ${missingKeys.join(", ")}`);
+}
+
+//#endregion
+export { uuid as $, isNaN as A, removeAt as At, snapValueToStep as B, getPercentValue as C, last as Ct, getValueSetterAtIndex as D, prev as Dt, getValueRanges as E, partition as Et, nan as F, cast as G, toPx as H, roundToDpr as I, match as J, debounce as K, roundToStepPrecision as L, isValueAtMin as M, uniq as Mt, isValueWithinRange as N, getValueTransformer as O, prevIndex as Ot, mod as P, tryCatch as Q, roundValue as R, getNextStepValue as S, isEmpty as St, getValuePercent as T, nextIndex as Tt, wrap as U, toFixedNumber as V, callAll as W, runIfFn as X, noop as Y, throttle as Z, decrementValue as _, first as _t, Timer as a, isNull as at, getMaxValueAtIndex as b, has as bt, createStore as c, isObjectLike as ct, json as d, isEqual as dt, hasProp as et, omit as f, add as ft, clampValue as g, diff as gt, clampPercent as h, clear as ht, warn as i, isFunction as it, isValueAtMax as j, toArray as jt, incrementValue as k, remove as kt, compact as l, isPlainObject as lt, splitProps as m, chunk as mt, ensureProps as n, isBoolean as nt, setRafInterval as o, isNumber as ot, pick as p, addOrRemove as pt, identity as q, invariant as r, isDev as rt, setRafTimeout as s, isObject as st, ensure as t, isArray as tt, createSplitProps as u, isString as ut, getClosestValue as v, flatArray as vt, getPreviousStepValue as w, next as wt, getMinValueAtIndex as x, insertAt as xt, getClosestValueIndex as y, fromLength as yt, setValueAtIndex as z };