@wirekyt/dom 0.0.1 → 0.0.2

package/dist/utils-Cht5XaHf.js

@@ -0,0 +1,267 @@
+//#region src/common/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/common/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);
+	});
+}
+const toChar = (code) => String.fromCharCode(code + (code > 25 ? 39 : 97));
+function toName(code) {
+	let name = "";
+	let x;
+	for (x = Math.abs(code); x > 52; x = x / 52 | 0) name = toChar(x % 52) + name;
+	return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+	let i = x.length;
+	while (i) h = h * 33 ^ x.charCodeAt(--i);
+	return h;
+}
+const hash = (value) => toName(toPhash(5381, value) >>> 0);
+//#endregion
+//#region src/common/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 = vmin != null ? Number(vmin) : 0;
+	const max = Number(vmax);
+	const remainder = (v - min) % step;
+	let snapped = abs(remainder) * 2 >= step ? v + sign(remainder) * (step - abs(remainder)) : v - remainder;
+	snapped = roundToStepPrecision(snapped, step);
+	if (!isNaN(min) && snapped < min) snapped = min;
+	else if (!isNaN(max) && snapped > max) {
+		const stepsInRange = floor((max - min) / step);
+		const largestValidStep = min + stepsInRange * step;
+		snapped = stepsInRange <= 0 || largestValidStep < min ? max : 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 = Math.pow(b, d);
+	return round(v * pow) / pow;
+};
+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/common/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));
+const keys = (obj) => Object.keys(obj);
+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
+export { isNull as $, roundToStepPrecision as A, hash as B, isNaN as C, mod as D, isValueWithinRange as E, toPx as F, throttle as G, match as H, wrap as I, hasProp as J, tryCatch as K, callAll as L, setValueAtIndex as M, snapValueToStep as N, nan as O, toFixedNumber as P, isFunction as Q, cast as R, incrementValue as S, isValueAtMin as T, noop as U, identity as V, runIfFn as W, isBoolean as X, isArray as Y, isDev as Z, getPreviousStepValue as _, omit as a, getValueSetterAtIndex as b, clampPercent as c, getClosestValue as d, isNumber as et, getClosestValueIndex as f, getPercentValue as g, getNextStepValue as h, keys as i, isString as it, roundValue as j, roundToDpr as k, clampValue as l, getMinValueAtIndex as m, createSplitProps as n, isObjectLike as nt, pick as o, getMaxValueAtIndex as p, uuid as q, json as r, isPlainObject as rt, splitProps as s, compact as t, isObject as tt, decrementValue as u, getValuePercent as v, isValueAtMax as w, getValueTransformer as x, getValueRanges as y, debounce as z };

package/dist/utils.cjs

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_array = require("./array-BGtygd0o.cjs");
+const require_equal = require("./equal-C927y7MN.cjs");
+const require_utils = require("./utils-BH-oBBz2.cjs");
+const require_store = require("./store-Btfrm2bs.cjs");
+const require_timers = require("./timers-Beu4SfAj.cjs");
+const require_warning = require("./warning-HAmFXLHm.cjs");
+exports.Timer = require_timers.Timer;
+exports.add = require_array.add;
+exports.addOrRemove = require_array.addOrRemove;
+exports.callAll = require_utils.callAll;
+exports.cast = require_utils.cast;
+exports.chunk = require_array.chunk;
+exports.clampPercent = require_utils.clampPercent;
+exports.clampValue = require_utils.clampValue;
+exports.clear = require_array.clear;
+exports.compact = require_utils.compact;
+exports.createSplitProps = require_utils.createSplitProps;
+exports.createStore = require_store.createStore;
+exports.debounce = require_utils.debounce;
+exports.decrementValue = require_utils.decrementValue;
+exports.diff = require_array.diff;
+exports.ensure = require_warning.ensure;
+exports.ensureProps = require_warning.ensureProps;
+exports.first = require_array.first;
+exports.flatArray = require_array.flatArray;
+exports.fromLength = require_array.fromLength;
+exports.getClosestValue = require_utils.getClosestValue;
+exports.getClosestValueIndex = require_utils.getClosestValueIndex;
+exports.getMaxValueAtIndex = require_utils.getMaxValueAtIndex;
+exports.getMinValueAtIndex = require_utils.getMinValueAtIndex;
+exports.getNextStepValue = require_utils.getNextStepValue;
+exports.getPercentValue = require_utils.getPercentValue;
+exports.getPreviousStepValue = require_utils.getPreviousStepValue;
+exports.getValuePercent = require_utils.getValuePercent;
+exports.getValueRanges = require_utils.getValueRanges;
+exports.getValueSetterAtIndex = require_utils.getValueSetterAtIndex;
+exports.getValueTransformer = require_utils.getValueTransformer;
+exports.has = require_array.has;
+exports.hasProp = require_utils.hasProp;
+exports.hash = require_utils.hash;
+exports.identity = require_utils.identity;
+exports.incrementValue = require_utils.incrementValue;
+exports.insertAt = require_array.insertAt;
+exports.invariant = require_warning.invariant;
+exports.isArray = require_utils.isArray;
+exports.isBoolean = require_utils.isBoolean;
+exports.isDev = require_utils.isDev;
+exports.isEmpty = require_array.isEmpty;
+exports.isEqual = require_equal.isEqual;
+exports.isFunction = require_utils.isFunction;
+exports.isNaN = require_utils.isNaN;
+exports.isNull = require_utils.isNull;
+exports.isNumber = require_utils.isNumber;
+exports.isObject = require_utils.isObject;
+exports.isObjectLike = require_utils.isObjectLike;
+exports.isPlainObject = require_utils.isPlainObject;
+exports.isString = require_utils.isString;
+exports.isValueAtMax = require_utils.isValueAtMax;
+exports.isValueAtMin = require_utils.isValueAtMin;
+exports.isValueWithinRange = require_utils.isValueWithinRange;
+exports.json = require_utils.json;
+exports.keys = require_utils.keys;
+exports.last = require_array.last;
+exports.match = require_utils.match;
+exports.mod = require_utils.mod;
+exports.nan = require_utils.nan;
+exports.next = require_array.next;
+exports.nextIndex = require_array.nextIndex;
+exports.noop = require_utils.noop;
+exports.omit = require_utils.omit;
+exports.partition = require_array.partition;
+exports.pick = require_utils.pick;
+exports.prev = require_array.prev;
+exports.prevIndex = require_array.prevIndex;
+exports.remove = require_array.remove;
+exports.removeAt = require_array.removeAt;
+exports.roundToDpr = require_utils.roundToDpr;
+exports.roundToStepPrecision = require_utils.roundToStepPrecision;
+exports.roundValue = require_utils.roundValue;
+exports.runIfFn = require_utils.runIfFn;
+exports.setRafInterval = require_timers.setRafInterval;
+exports.setRafTimeout = require_timers.setRafTimeout;
+exports.setValueAtIndex = require_utils.setValueAtIndex;
+exports.snapValueToStep = require_utils.snapValueToStep;
+exports.splitProps = require_utils.splitProps;
+exports.throttle = require_utils.throttle;
+exports.toArray = require_array.toArray;
+exports.toFixedNumber = require_utils.toFixedNumber;
+exports.toPx = require_utils.toPx;
+exports.tryCatch = require_utils.tryCatch;
+exports.uniq = require_array.uniq;
+exports.uuid = require_utils.uuid;
+exports.warn = require_warning.warn;
+exports.wrap = require_utils.wrap;

package/dist/utils.d.cts

@@ -0,0 +1,144 @@
+import { a as debounce, c as match, d as throttle, f as tryCatch, i as cast, l as noop, n as Nullable, o as hash, p as uuid, r as callAll, s as identity, t as MaybeFunction, u as runIfFn } from "./functions-isw5Ovcx.cjs";
+//#region src/common/utils/array.d.ts
+declare function toArray<T>(v: T | T[] | undefined | null): T[];
+declare const fromLength: (length: number) => number[];
+declare const first: <T>(v: T[]) => T | undefined;
+declare const last: <T>(v: T[]) => T | undefined;
+declare const isEmpty: <T>(v: T[]) => boolean;
+declare const has: <T>(v: T[], t: T) => boolean;
+declare const add: <T>(v: T[], ...items: T[]) => T[];
+declare const remove: <T>(v: T[], ...items: T[]) => T[];
+declare const removeAt: <T>(v: T[], i: number) => T[];
+declare const insertAt: <T>(v: T[], i: number, ...items: T[]) => T[];
+declare const uniq: <T>(v: T[]) => T[];
+declare const diff: <T>(a: T[], b: T[]) => T[];
+declare const addOrRemove: <T>(v: T[], item: T) => T[];
+declare function clear<T>(v: T[]): T[];
+type IndexOptions = {
+  step?: number | undefined;
+  loop?: boolean | undefined;
+};
+declare function nextIndex<T>(v: T[], idx: number, opts?: IndexOptions): number;
+declare function next<T>(v: T[], idx: number, opts?: IndexOptions): T | undefined;
+declare function prevIndex<T>(v: T[], idx: number, opts?: IndexOptions): number;
+declare function prev<T>(v: T[], index: number, opts?: IndexOptions): T | undefined;
+declare function chunk<T>(v: T[], size: number): T[][];
+declare function flatArray<T>(arr: T[]): T[];
+declare function partition<T>(arr: T[], fn: (value: T) => boolean): [T[], T[]];
+//#endregion
+//#region src/common/utils/equal.d.ts
+declare const isEqual: (a: any, b: any) => boolean;
+//#endregion
+//#region src/common/utils/guard.d.ts
+type AnyFunction = (...args: any[]) => any;
+declare const isDev: () => boolean;
+declare const isArray: (v: any) => v is any[];
+declare const isBoolean: (v: any) => v is boolean;
+declare const isObjectLike: (v: any) => v is Record<string, any>;
+declare const isObject: (v: any) => v is Record<string, any>;
+declare const isNumber: (v: any) => v is number;
+declare const isString: (v: any) => v is string;
+declare const isFunction: (v: any) => v is AnyFunction;
+declare const isNull: (v: any) => v is null | undefined;
+declare const hasProp: <T extends string>(obj: any, prop: T) => obj is Record<T, any>;
+declare const isPlainObject: (v: any) => boolean;
+//#endregion
+//#region src/common/utils/number.d.ts
+declare const isNaN: (v: number) => boolean;
+declare const nan: (v: number) => number;
+declare const mod: (v: number, m: number) => number;
+declare const wrap: (v: number, vmax: number) => number;
+declare const getMinValueAtIndex: (i: number, v: number[], vmin: number) => number;
+declare const getMaxValueAtIndex: (i: number, v: number[], vmax: number) => number;
+declare const isValueAtMax: (v: number, vmax: number) => boolean;
+declare const isValueAtMin: (v: number, vmin: number) => boolean;
+declare const isValueWithinRange: (v: number, vmin: number | null | undefined, vmax: number | null | undefined) => boolean;
+declare const roundValue: (v: number, vmin: number, step: number) => number;
+declare const clampValue: (v: number, vmin: number, vmax: number) => number;
+declare const clampPercent: (v: number) => number;
+declare const getValuePercent: (v: number, vmin: number, vmax: number) => number;
+declare const getPercentValue: (p: number, vmin: number, vmax: number, step: number) => number;
+declare const roundToStepPrecision: (v: number, step: number) => number;
+declare const roundToDpr: (v: number, dpr: unknown) => number;
+declare const snapValueToStep: (v: number, vmin: number | undefined, vmax: number | undefined, step: number) => number;
+declare const setValueAtIndex: <T>(vs: T[], i: number, v: T) => T[];
+interface RangeContext {
+  min: number;
+  max: number;
+  step: number;
+  values: number[];
+}
+declare function getValueSetterAtIndex(index: number, ctx: RangeContext): (value: number) => number[];
+declare function getNextStepValue(index: number, ctx: RangeContext): number[];
+declare function getPreviousStepValue(index: number, ctx: RangeContext): number[];
+declare const getClosestValueIndex: (vs: number[], t: number) => number;
+declare const getClosestValue: (vs: number[], t: number) => number;
+declare const getValueRanges: (vs: number[], vmin: number, vmax: number, gap: number) => {
+  min: number;
+  max: number;
+  value: number;
+}[];
+declare const getValueTransformer: (va: number[], vb: number[]) => (v: number) => number;
+declare const toFixedNumber: (v: number, d?: number, b?: number) => number;
+declare const incrementValue: (v: number, s: number) => number;
+declare const decrementValue: (v: number, s: number) => number;
+declare const toPx: (v: number | string | undefined) => string | undefined;
+//#endregion
+//#region src/common/utils/object.d.ts
+declare function compact<T extends Record<string, unknown> | undefined>(obj: T): T;
+declare const json: (v: any) => any;
+declare const keys: <T extends Record<string, any>>(obj: T) => (keyof T)[];
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+type Dict = Record<string | symbol, any>;
+declare function splitProps<T extends Dict>(props: T, keys: (keyof T)[]): Dict[];
+declare const createSplitProps: <T extends Dict>(keys: (keyof T)[]) => <Props extends T>(props: Props) => [T, Omit<Props, keyof T>];
+declare function omit<T extends Record<string, any>>(obj: T, keys: string[]): Omit<T, string | number>;
+//#endregion
+//#region src/common/utils/store.d.ts
+type StoreListener = VoidFunction;
+type StoreCompareFn<T> = (a: T, b: T) => boolean;
+declare function createStore<T extends Record<string, any>>(initialState: T, compare?: StoreCompareFn<T>): Store<T>;
+interface Store<T extends Record<string, any>> {
+  subscribe: (listener: StoreListener) => () => void;
+  get: <K extends keyof T>(key: K) => T[K];
+  set: <K extends keyof T>(key: K, value: T[K]) => void;
+  update: (updates: Partial<T>) => void;
+  snapshot: () => T;
+}
+//#endregion
+//#region src/common/utils/timers.d.ts
+interface TimerBaseContext {
+  startMs: number;
+  deltaMs: number;
+}
+interface TimerContext extends TimerBaseContext {
+  now: number;
+}
+type TimerContextFn = (ctx: TimerContext) => boolean | void;
+declare class Timer {
+  #private;
+  private readonly onTick;
+  private frameId;
+  private pausedAtMs;
+  private context;
+  constructor(onTick: TimerContextFn);
+  private cancelFrame;
+  setStartMs: (startMs: number) => void;
+  get elapsedMs(): number;
+  start: () => void;
+  pause: () => void;
+  stop: () => void;
+}
+declare function setRafInterval(fn: (ctx: TimerBaseContext) => void, intervalMs: number): () => void;
+declare function setRafTimeout(fn: () => void, delayMs: number): () => void;
+//#endregion
+//#region src/common/utils/warning.d.ts
+declare function warn(m: string): void;
+declare function warn(c: boolean, m: string): void;
+declare function invariant(m: string): void;
+declare function invariant(c: boolean, m: string): void;
+declare function ensure<T>(c: T | null | undefined, m: () => string): asserts c is T;
+type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+declare function ensureProps<T, K extends keyof T>(props: T, keys: K[], scope?: string): asserts props is T & RequiredBy<T, K>;
+//#endregion
+export { IndexOptions, MaybeFunction, Nullable, Store, StoreCompareFn, StoreListener, Timer, TimerBaseContext, TimerContextFn, add, addOrRemove, callAll, cast, chunk, clampPercent, clampValue, clear, compact, createSplitProps, createStore, debounce, decrementValue, diff, ensure, ensureProps, first, flatArray, fromLength, getClosestValue, getClosestValueIndex, getMaxValueAtIndex, getMinValueAtIndex, getNextStepValue, getPercentValue, getPreviousStepValue, getValuePercent, getValueRanges, getValueSetterAtIndex, getValueTransformer, has, hasProp, hash, identity, incrementValue, insertAt, invariant, isArray, isBoolean, isDev, isEmpty, isEqual, isFunction, isNaN, isNull, isNumber, isObject, isObjectLike, isPlainObject, isString, isValueAtMax, isValueAtMin, isValueWithinRange, json, keys, last, match, mod, nan, next, nextIndex, noop, omit, partition, pick, prev, prevIndex, remove, removeAt, roundToDpr, roundToStepPrecision, roundValue, runIfFn, setRafInterval, setRafTimeout, setValueAtIndex, snapValueToStep, splitProps, throttle, toArray, toFixedNumber, toPx, tryCatch, uniq, uuid, warn, wrap };

package/dist/utils.d.ts

@@ -0,0 +1,144 @@
+import { a as debounce, c as match, d as throttle, f as tryCatch, i as cast, l as noop, n as Nullable, o as hash, p as uuid, r as callAll, s as identity, t as MaybeFunction, u as runIfFn } from "./functions-isw5Ovcx.js";
+//#region src/common/utils/array.d.ts
+declare function toArray<T>(v: T | T[] | undefined | null): T[];
+declare const fromLength: (length: number) => number[];
+declare const first: <T>(v: T[]) => T | undefined;
+declare const last: <T>(v: T[]) => T | undefined;
+declare const isEmpty: <T>(v: T[]) => boolean;
+declare const has: <T>(v: T[], t: T) => boolean;
+declare const add: <T>(v: T[], ...items: T[]) => T[];
+declare const remove: <T>(v: T[], ...items: T[]) => T[];
+declare const removeAt: <T>(v: T[], i: number) => T[];
+declare const insertAt: <T>(v: T[], i: number, ...items: T[]) => T[];
+declare const uniq: <T>(v: T[]) => T[];
+declare const diff: <T>(a: T[], b: T[]) => T[];
+declare const addOrRemove: <T>(v: T[], item: T) => T[];
+declare function clear<T>(v: T[]): T[];
+type IndexOptions = {
+  step?: number | undefined;
+  loop?: boolean | undefined;
+};
+declare function nextIndex<T>(v: T[], idx: number, opts?: IndexOptions): number;
+declare function next<T>(v: T[], idx: number, opts?: IndexOptions): T | undefined;
+declare function prevIndex<T>(v: T[], idx: number, opts?: IndexOptions): number;
+declare function prev<T>(v: T[], index: number, opts?: IndexOptions): T | undefined;
+declare function chunk<T>(v: T[], size: number): T[][];
+declare function flatArray<T>(arr: T[]): T[];
+declare function partition<T>(arr: T[], fn: (value: T) => boolean): [T[], T[]];
+//#endregion
+//#region src/common/utils/equal.d.ts
+declare const isEqual: (a: any, b: any) => boolean;
+//#endregion
+//#region src/common/utils/guard.d.ts
+type AnyFunction = (...args: any[]) => any;
+declare const isDev: () => boolean;
+declare const isArray: (v: any) => v is any[];
+declare const isBoolean: (v: any) => v is boolean;
+declare const isObjectLike: (v: any) => v is Record<string, any>;
+declare const isObject: (v: any) => v is Record<string, any>;
+declare const isNumber: (v: any) => v is number;
+declare const isString: (v: any) => v is string;
+declare const isFunction: (v: any) => v is AnyFunction;
+declare const isNull: (v: any) => v is null | undefined;
+declare const hasProp: <T extends string>(obj: any, prop: T) => obj is Record<T, any>;
+declare const isPlainObject: (v: any) => boolean;
+//#endregion
+//#region src/common/utils/number.d.ts
+declare const isNaN: (v: number) => boolean;
+declare const nan: (v: number) => number;
+declare const mod: (v: number, m: number) => number;
+declare const wrap: (v: number, vmax: number) => number;
+declare const getMinValueAtIndex: (i: number, v: number[], vmin: number) => number;
+declare const getMaxValueAtIndex: (i: number, v: number[], vmax: number) => number;
+declare const isValueAtMax: (v: number, vmax: number) => boolean;
+declare const isValueAtMin: (v: number, vmin: number) => boolean;
+declare const isValueWithinRange: (v: number, vmin: number | null | undefined, vmax: number | null | undefined) => boolean;
+declare const roundValue: (v: number, vmin: number, step: number) => number;
+declare const clampValue: (v: number, vmin: number, vmax: number) => number;
+declare const clampPercent: (v: number) => number;
+declare const getValuePercent: (v: number, vmin: number, vmax: number) => number;
+declare const getPercentValue: (p: number, vmin: number, vmax: number, step: number) => number;
+declare const roundToStepPrecision: (v: number, step: number) => number;
+declare const roundToDpr: (v: number, dpr: unknown) => number;
+declare const snapValueToStep: (v: number, vmin: number | undefined, vmax: number | undefined, step: number) => number;
+declare const setValueAtIndex: <T>(vs: T[], i: number, v: T) => T[];
+interface RangeContext {
+  min: number;
+  max: number;
+  step: number;
+  values: number[];
+}
+declare function getValueSetterAtIndex(index: number, ctx: RangeContext): (value: number) => number[];
+declare function getNextStepValue(index: number, ctx: RangeContext): number[];
+declare function getPreviousStepValue(index: number, ctx: RangeContext): number[];
+declare const getClosestValueIndex: (vs: number[], t: number) => number;
+declare const getClosestValue: (vs: number[], t: number) => number;
+declare const getValueRanges: (vs: number[], vmin: number, vmax: number, gap: number) => {
+  min: number;
+  max: number;
+  value: number;
+}[];
+declare const getValueTransformer: (va: number[], vb: number[]) => (v: number) => number;
+declare const toFixedNumber: (v: number, d?: number, b?: number) => number;
+declare const incrementValue: (v: number, s: number) => number;
+declare const decrementValue: (v: number, s: number) => number;
+declare const toPx: (v: number | string | undefined) => string | undefined;
+//#endregion
+//#region src/common/utils/object.d.ts
+declare function compact<T extends Record<string, unknown> | undefined>(obj: T): T;
+declare const json: (v: any) => any;
+declare const keys: <T extends Record<string, any>>(obj: T) => (keyof T)[];
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+type Dict = Record<string | symbol, any>;
+declare function splitProps<T extends Dict>(props: T, keys: (keyof T)[]): Dict[];
+declare const createSplitProps: <T extends Dict>(keys: (keyof T)[]) => <Props extends T>(props: Props) => [T, Omit<Props, keyof T>];
+declare function omit<T extends Record<string, any>>(obj: T, keys: string[]): Omit<T, string | number>;
+//#endregion
+//#region src/common/utils/store.d.ts
+type StoreListener = VoidFunction;
+type StoreCompareFn<T> = (a: T, b: T) => boolean;
+declare function createStore<T extends Record<string, any>>(initialState: T, compare?: StoreCompareFn<T>): Store<T>;
+interface Store<T extends Record<string, any>> {
+  subscribe: (listener: StoreListener) => () => void;
+  get: <K extends keyof T>(key: K) => T[K];
+  set: <K extends keyof T>(key: K, value: T[K]) => void;
+  update: (updates: Partial<T>) => void;
+  snapshot: () => T;
+}
+//#endregion
+//#region src/common/utils/timers.d.ts
+interface TimerBaseContext {
+  startMs: number;
+  deltaMs: number;
+}
+interface TimerContext extends TimerBaseContext {
+  now: number;
+}
+type TimerContextFn = (ctx: TimerContext) => boolean | void;
+declare class Timer {
+  #private;
+  private readonly onTick;
+  private frameId;
+  private pausedAtMs;
+  private context;
+  constructor(onTick: TimerContextFn);
+  private cancelFrame;
+  setStartMs: (startMs: number) => void;
+  get elapsedMs(): number;
+  start: () => void;
+  pause: () => void;
+  stop: () => void;
+}
+declare function setRafInterval(fn: (ctx: TimerBaseContext) => void, intervalMs: number): () => void;
+declare function setRafTimeout(fn: () => void, delayMs: number): () => void;
+//#endregion
+//#region src/common/utils/warning.d.ts
+declare function warn(m: string): void;
+declare function warn(c: boolean, m: string): void;
+declare function invariant(m: string): void;
+declare function invariant(c: boolean, m: string): void;
+declare function ensure<T>(c: T | null | undefined, m: () => string): asserts c is T;
+type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+declare function ensureProps<T, K extends keyof T>(props: T, keys: K[], scope?: string): asserts props is T & RequiredBy<T, K>;
+//#endregion
+export { IndexOptions, MaybeFunction, Nullable, Store, StoreCompareFn, StoreListener, Timer, TimerBaseContext, TimerContextFn, add, addOrRemove, callAll, cast, chunk, clampPercent, clampValue, clear, compact, createSplitProps, createStore, debounce, decrementValue, diff, ensure, ensureProps, first, flatArray, fromLength, getClosestValue, getClosestValueIndex, getMaxValueAtIndex, getMinValueAtIndex, getNextStepValue, getPercentValue, getPreviousStepValue, getValuePercent, getValueRanges, getValueSetterAtIndex, getValueTransformer, has, hasProp, hash, identity, incrementValue, insertAt, invariant, isArray, isBoolean, isDev, isEmpty, isEqual, isFunction, isNaN, isNull, isNumber, isObject, isObjectLike, isPlainObject, isString, isValueAtMax, isValueAtMin, isValueWithinRange, json, keys, last, match, mod, nan, next, nextIndex, noop, omit, partition, pick, prev, prevIndex, remove, removeAt, roundToDpr, roundToStepPrecision, roundValue, runIfFn, setRafInterval, setRafTimeout, setValueAtIndex, snapValueToStep, splitProps, throttle, toArray, toFixedNumber, toPx, tryCatch, uniq, uuid, warn, wrap };

package/dist/utils.js

@@ -0,0 +1,7 @@
+import { _ as prevIndex, a as diff, b as toArray, c as fromLength, d as isEmpty, f as last, g as prev, h as partition, i as clear, l as has, m as nextIndex, n as addOrRemove, o as first, p as next, r as chunk, s as flatArray, t as add, u as insertAt, v as remove, x as uniq, y as removeAt } from "./array-C4KbHsha.js";
+import { t as isEqual } from "./equal-DtrP8DPh.js";
+import { $ as isNull, A as roundToStepPrecision, B as hash, C as isNaN, D as mod, E as isValueWithinRange, F as toPx, G as throttle, H as match, I as wrap, J as hasProp, K as tryCatch, L as callAll, M as setValueAtIndex, N as snapValueToStep, O as nan, P as toFixedNumber, Q as isFunction, R as cast, S as incrementValue, T as isValueAtMin, U as noop, V as identity, W as runIfFn, X as isBoolean, Y as isArray, Z as isDev, _ as getPreviousStepValue, a as omit, b as getValueSetterAtIndex, c as clampPercent, d as getClosestValue, et as isNumber, f as getClosestValueIndex, g as getPercentValue, h as getNextStepValue, i as keys, it as isString, j as roundValue, k as roundToDpr, l as clampValue, m as getMinValueAtIndex, n as createSplitProps, nt as isObjectLike, o as pick, p as getMaxValueAtIndex, q as uuid, r as json, rt as isPlainObject, s as splitProps, t as compact, tt as isObject, u as decrementValue, v as getValuePercent, w as isValueAtMax, x as getValueTransformer, y as getValueRanges, z as debounce } from "./utils-Cht5XaHf.js";
+import { t as createStore } from "./store-C5HvdLyc.js";
+import { n as setRafInterval, r as setRafTimeout, t as Timer } from "./timers-BRyPrXIX.js";
+import { i as warn, n as ensureProps, r as invariant, t as ensure } from "./warning-CrzBpWT1.js";
+export { Timer, add, addOrRemove, callAll, cast, chunk, clampPercent, clampValue, clear, compact, createSplitProps, createStore, debounce, decrementValue, diff, ensure, ensureProps, first, flatArray, fromLength, getClosestValue, getClosestValueIndex, getMaxValueAtIndex, getMinValueAtIndex, getNextStepValue, getPercentValue, getPreviousStepValue, getValuePercent, getValueRanges, getValueSetterAtIndex, getValueTransformer, has, hasProp, hash, identity, incrementValue, insertAt, invariant, isArray, isBoolean, isDev, isEmpty, isEqual, isFunction, isNaN, isNull, isNumber, isObject, isObjectLike, isPlainObject, isString, isValueAtMax, isValueAtMin, isValueWithinRange, json, keys, last, match, mod, nan, next, nextIndex, noop, omit, partition, pick, prev, prevIndex, remove, removeAt, roundToDpr, roundToStepPrecision, roundValue, runIfFn, setRafInterval, setRafTimeout, setValueAtIndex, snapValueToStep, splitProps, throttle, toArray, toFixedNumber, toPx, tryCatch, uniq, uuid, warn, wrap };