@wirekyt/dom 0.0.1 → 0.0.2

package/dist/utils-BH-oBBz2.cjs

@@ -0,0 +1,614 @@
+//#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
+Object.defineProperty(exports, "callAll", {
+	enumerable: true,
+	get: function() {
+		return callAll;
+	}
+});
+Object.defineProperty(exports, "cast", {
+	enumerable: true,
+	get: function() {
+		return cast;
+	}
+});
+Object.defineProperty(exports, "clampPercent", {
+	enumerable: true,
+	get: function() {
+		return clampPercent;
+	}
+});
+Object.defineProperty(exports, "clampValue", {
+	enumerable: true,
+	get: function() {
+		return clampValue;
+	}
+});
+Object.defineProperty(exports, "compact", {
+	enumerable: true,
+	get: function() {
+		return compact;
+	}
+});
+Object.defineProperty(exports, "createSplitProps", {
+	enumerable: true,
+	get: function() {
+		return createSplitProps;
+	}
+});
+Object.defineProperty(exports, "debounce", {
+	enumerable: true,
+	get: function() {
+		return debounce;
+	}
+});
+Object.defineProperty(exports, "decrementValue", {
+	enumerable: true,
+	get: function() {
+		return decrementValue;
+	}
+});
+Object.defineProperty(exports, "getClosestValue", {
+	enumerable: true,
+	get: function() {
+		return getClosestValue;
+	}
+});
+Object.defineProperty(exports, "getClosestValueIndex", {
+	enumerable: true,
+	get: function() {
+		return getClosestValueIndex;
+	}
+});
+Object.defineProperty(exports, "getMaxValueAtIndex", {
+	enumerable: true,
+	get: function() {
+		return getMaxValueAtIndex;
+	}
+});
+Object.defineProperty(exports, "getMinValueAtIndex", {
+	enumerable: true,
+	get: function() {
+		return getMinValueAtIndex;
+	}
+});
+Object.defineProperty(exports, "getNextStepValue", {
+	enumerable: true,
+	get: function() {
+		return getNextStepValue;
+	}
+});
+Object.defineProperty(exports, "getPercentValue", {
+	enumerable: true,
+	get: function() {
+		return getPercentValue;
+	}
+});
+Object.defineProperty(exports, "getPreviousStepValue", {
+	enumerable: true,
+	get: function() {
+		return getPreviousStepValue;
+	}
+});
+Object.defineProperty(exports, "getValuePercent", {
+	enumerable: true,
+	get: function() {
+		return getValuePercent;
+	}
+});
+Object.defineProperty(exports, "getValueRanges", {
+	enumerable: true,
+	get: function() {
+		return getValueRanges;
+	}
+});
+Object.defineProperty(exports, "getValueSetterAtIndex", {
+	enumerable: true,
+	get: function() {
+		return getValueSetterAtIndex;
+	}
+});
+Object.defineProperty(exports, "getValueTransformer", {
+	enumerable: true,
+	get: function() {
+		return getValueTransformer;
+	}
+});
+Object.defineProperty(exports, "hasProp", {
+	enumerable: true,
+	get: function() {
+		return hasProp;
+	}
+});
+Object.defineProperty(exports, "hash", {
+	enumerable: true,
+	get: function() {
+		return hash;
+	}
+});
+Object.defineProperty(exports, "identity", {
+	enumerable: true,
+	get: function() {
+		return identity;
+	}
+});
+Object.defineProperty(exports, "incrementValue", {
+	enumerable: true,
+	get: function() {
+		return incrementValue;
+	}
+});
+Object.defineProperty(exports, "isArray", {
+	enumerable: true,
+	get: function() {
+		return isArray;
+	}
+});
+Object.defineProperty(exports, "isBoolean", {
+	enumerable: true,
+	get: function() {
+		return isBoolean;
+	}
+});
+Object.defineProperty(exports, "isDev", {
+	enumerable: true,
+	get: function() {
+		return isDev;
+	}
+});
+Object.defineProperty(exports, "isFunction", {
+	enumerable: true,
+	get: function() {
+		return isFunction;
+	}
+});
+Object.defineProperty(exports, "isNaN", {
+	enumerable: true,
+	get: function() {
+		return isNaN;
+	}
+});
+Object.defineProperty(exports, "isNull", {
+	enumerable: true,
+	get: function() {
+		return isNull;
+	}
+});
+Object.defineProperty(exports, "isNumber", {
+	enumerable: true,
+	get: function() {
+		return isNumber;
+	}
+});
+Object.defineProperty(exports, "isObject", {
+	enumerable: true,
+	get: function() {
+		return isObject;
+	}
+});
+Object.defineProperty(exports, "isObjectLike", {
+	enumerable: true,
+	get: function() {
+		return isObjectLike;
+	}
+});
+Object.defineProperty(exports, "isPlainObject", {
+	enumerable: true,
+	get: function() {
+		return isPlainObject;
+	}
+});
+Object.defineProperty(exports, "isString", {
+	enumerable: true,
+	get: function() {
+		return isString;
+	}
+});
+Object.defineProperty(exports, "isValueAtMax", {
+	enumerable: true,
+	get: function() {
+		return isValueAtMax;
+	}
+});
+Object.defineProperty(exports, "isValueAtMin", {
+	enumerable: true,
+	get: function() {
+		return isValueAtMin;
+	}
+});
+Object.defineProperty(exports, "isValueWithinRange", {
+	enumerable: true,
+	get: function() {
+		return isValueWithinRange;
+	}
+});
+Object.defineProperty(exports, "json", {
+	enumerable: true,
+	get: function() {
+		return json;
+	}
+});
+Object.defineProperty(exports, "keys", {
+	enumerable: true,
+	get: function() {
+		return keys;
+	}
+});
+Object.defineProperty(exports, "match", {
+	enumerable: true,
+	get: function() {
+		return match;
+	}
+});
+Object.defineProperty(exports, "mod", {
+	enumerable: true,
+	get: function() {
+		return mod;
+	}
+});
+Object.defineProperty(exports, "nan", {
+	enumerable: true,
+	get: function() {
+		return nan;
+	}
+});
+Object.defineProperty(exports, "noop", {
+	enumerable: true,
+	get: function() {
+		return noop;
+	}
+});
+Object.defineProperty(exports, "omit", {
+	enumerable: true,
+	get: function() {
+		return omit;
+	}
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: function() {
+		return pick;
+	}
+});
+Object.defineProperty(exports, "roundToDpr", {
+	enumerable: true,
+	get: function() {
+		return roundToDpr;
+	}
+});
+Object.defineProperty(exports, "roundToStepPrecision", {
+	enumerable: true,
+	get: function() {
+		return roundToStepPrecision;
+	}
+});
+Object.defineProperty(exports, "roundValue", {
+	enumerable: true,
+	get: function() {
+		return roundValue;
+	}
+});
+Object.defineProperty(exports, "runIfFn", {
+	enumerable: true,
+	get: function() {
+		return runIfFn;
+	}
+});
+Object.defineProperty(exports, "setValueAtIndex", {
+	enumerable: true,
+	get: function() {
+		return setValueAtIndex;
+	}
+});
+Object.defineProperty(exports, "snapValueToStep", {
+	enumerable: true,
+	get: function() {
+		return snapValueToStep;
+	}
+});
+Object.defineProperty(exports, "splitProps", {
+	enumerable: true,
+	get: function() {
+		return splitProps;
+	}
+});
+Object.defineProperty(exports, "throttle", {
+	enumerable: true,
+	get: function() {
+		return throttle;
+	}
+});
+Object.defineProperty(exports, "toFixedNumber", {
+	enumerable: true,
+	get: function() {
+		return toFixedNumber;
+	}
+});
+Object.defineProperty(exports, "toPx", {
+	enumerable: true,
+	get: function() {
+		return toPx;
+	}
+});
+Object.defineProperty(exports, "tryCatch", {
+	enumerable: true,
+	get: function() {
+		return tryCatch;
+	}
+});
+Object.defineProperty(exports, "uuid", {
+	enumerable: true,
+	get: function() {
+		return uuid;
+	}
+});
+Object.defineProperty(exports, "wrap", {
+	enumerable: true,
+	get: function() {
+		return wrap;
+	}
+});