@tarsis/toolkit 0.6.6 → 0.7.1

package/dist/utils.d.ts

@@ -22,6 +22,13 @@ export declare class BaseLogger {
     };
 }
 
+export declare type BoundedMap<K, V> = ReturnType<typeof createBoundedMap<K, V>>;
+
+export declare type BoundedMapOptions = {
+    maxSize: number;
+    ttlMs?: number;
+};
+
 export declare const chain: (...elements: ReactNode[]) => JSX.Element[];
 
 export declare const clearSession: () => void;
@@ -30,6 +37,25 @@ export declare const componentLogger: BaseLogger;
 
 declare type Constructor<T> = new (...args: any[]) => T;
 
+/**
+ * LRU map with optional TTL. Evicts least-recently-used entries
+ * when maxSize is exceeded, and expired entries on access.
+ */
+export declare function createBoundedMap<K, V>(options: BoundedMapOptions): {
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    clear(): void;
+    readonly size: number;
+};
+
+/**
+ * Create standardized enter/exit motion variants using toolkit tokens.
+ * Returns `{ initial, animate, exit }` for framer-motion / motion.
+ */
+export declare const createPresenceVariants: (enter: Record<string, unknown>, exit: Record<string, unknown>, duration?: number, easingCurve?: readonly [number, number, number, number]) => PresenceVariants;
+
 export declare function delay(ms: number): Promise<unknown>;
 
 /**
@@ -39,6 +65,19 @@ export declare function distance(x1: number, x2: number, y1: number, y2: number)
 
 export declare const eventLogger: BaseLogger;
 
+export declare const fadePresence: PresenceVariants;
+
+/**
+ * Formats seconds into MM:SS display string.
+ */
+export declare function formatDuration(totalSeconds: number): string;
+
+/**
+ * Formats milliseconds into MM:SS.ms display string.
+ * Useful for timers and stopwatches.
+ */
+export declare function formatTime(totalMs: number): string;
+
 export declare const getCurrentLogLevel: () => LogLevel;
 
 export declare function getPath(x: number, smoothing: number): string;
@@ -69,22 +108,58 @@ export declare const move: <T>(source: T[], start: number, end: number) => T[];
 
 export declare const noop: (..._args: unknown[]) => void;
 
+/**
+ * Normalises unknown thrown values into proper Error instances.
+ * Preserves original Error objects; wraps strings and unknowns.
+ */
+export declare function normalizeError(err: unknown): Error;
+
 export declare const notReachable: (arg: never) => never;
 
+export declare type PresenceVariants = {
+    initial: Record<string, unknown>;
+    animate: Record<string, unknown>;
+    exit: Record<string, unknown>;
+};
+
+export declare const scalePresence: PresenceVariants;
+
 export declare const setLogLevel: (level: LogLevel) => void;
 
 export declare const setRequestId: (id: string) => void;
 
 export declare const setSessionId: (id: string) => void;
 
+export declare const slideDownPresence: PresenceVariants;
+
+export declare const slideUpPresence: PresenceVariants;
+
+/**
+ * Wrapper around the View Transitions API.
+ * Uses `document.startViewTransition` when available (Chrome 111+, Safari 18+),
+ * falls back to calling the callback directly on unsupported browsers.
+ */
+export declare const startViewTransition: (callback: () => void | Promise<void>) => ViewTransitionReturn;
+
 export declare const storageLogger: BaseLogger;
 
+/**
+ * Check if the View Transitions API is supported in the current browser.
+ */
+export declare const supportsViewTransitions: () => boolean;
+
 export declare const times: <T>(fn: (index: number) => T, size: number) => T[];
 
 export declare const utilsLogger: BaseLogger;
 
 export declare const values: <T extends Record<string | number | symbol, any>>(input: T) => Array<T[keyof T]>;
 
+export declare type ViewTransitionReturn = {
+    finished: Promise<void>;
+    ready: Promise<void>;
+    updateCallbackDone: Promise<void>;
+};
+
 export declare const wait: (ms: number) => Promise<unknown>;
 
 export { }

package/dist/utils.js

@@ -1 +1,3 @@
-export { B as BaseLogger, e as animationLogger, g as apiLogger, w as chain, c as clearSession, d as componentLogger, A as delay, x as distance, f as eventLogger, j as getCurrentLogLevel, D as getPath, h as hookLogger, o as is, k as isDebugEnabled, p as isNonNullable, r as keys, z as lerp, y as lineEq, l as logger, m as move, n as noop, q as notReachable, s as setLogLevel, b as setRequestId, a as setSessionId, i as storageLogger, t as times, u as utilsLogger, v as values, C as wait } from './svg-CQLdTbLk.js';
+import { C as move, S as times, _ as setLogLevel, a as is, b as storageLogger, c as animationLogger, d as componentLogger, f as eventLogger, g as logger, h as isDebugEnabled, i as isNonNullable, l as apiLogger, m as hookLogger, n as keys, o as noop, p as getCurrentLogLevel, r as notReachable, s as BaseLogger, t as values, u as clearSession, v as setRequestId, x as utilsLogger, y as setSessionId } from "./values-BTw18-W5.js";
+import { _ as chain, a as wait, c as scalePresence, d as distance, f as lerp, g as normalizeError, h as formatTime, i as delay, l as slideDownPresence, m as formatDuration, n as supportsViewTransitions, o as createPresenceVariants, p as lineEq, r as getPath, s as fadePresence, t as startViewTransition, u as slideUpPresence, v as createBoundedMap } from "./utils-Dw5El_3G.js";
+export { BaseLogger, animationLogger, apiLogger, chain, clearSession, componentLogger, createBoundedMap, createPresenceVariants, delay, distance, eventLogger, fadePresence, formatDuration, formatTime, getCurrentLogLevel, getPath, hookLogger, is, isDebugEnabled, isNonNullable, keys, lerp, lineEq, logger, move, noop, normalizeError, notReachable, scalePresence, setLogLevel, setRequestId, setSessionId, slideDownPresence, slideUpPresence, startViewTransition, storageLogger, supportsViewTransitions, times, utilsLogger, values, wait };

package/dist/values-BTw18-W5.js

@@ -0,0 +1,138 @@
+//#region src/utils/array/move.ts
+var move = (source, start, end) => {
+	const item = source[start];
+	const result = source.slice(0);
+	result.splice(start, 1);
+	result.splice(end, 0, item);
+	return result;
+};
+//#endregion
+//#region src/utils/array/times.ts
+var times = (fn, size) => Array.from({ length: size }, (_, index) => fn(index));
+//#endregion
+//#region src/utils/common/logger.ts
+var logRank = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+var getEnvLogLevel = () => {
+	if (typeof process === "undefined") return "info";
+	const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+	return envLevel && Object.prototype.hasOwnProperty.call(logRank, envLevel) ? envLevel : "info";
+};
+var currentLevel = getEnvLogLevel();
+var setLogLevel = (level) => {
+	if (Object.prototype.hasOwnProperty.call(logRank, level)) currentLevel = level;
+};
+var getTimestamp = () => {
+	const now = /* @__PURE__ */ new Date();
+	return now.toTimeString().split(" ")[0] + "." + now.getMilliseconds().toString().padStart(3, "0");
+};
+var shouldLog = (level) => {
+	return logRank[level] <= logRank[currentLevel];
+};
+var sessionId = null;
+var requestId = null;
+var setSessionId = (id) => {
+	sessionId = id;
+};
+var setRequestId = (id) => {
+	requestId = id;
+};
+var clearSession = () => {
+	sessionId = null;
+	requestId = null;
+};
+var getSessionInfo = () => {
+	const parts = [];
+	if (sessionId) parts.push(`session:${sessionId}`);
+	if (requestId) parts.push(`req:${requestId}`);
+	return parts.length > 0 ? `[${parts.join("|")}]` : "";
+};
+var BaseLogger = class {
+	prefix;
+	emoji;
+	constructor(prefix, emoji) {
+		this.prefix = prefix;
+		this.emoji = emoji;
+	}
+	log(level, emoji, msg, fn = console.log, data) {
+		if (shouldLog(level)) {
+			const sessionInfo = getSessionInfo();
+			fn(`[${getTimestamp()}] ${emoji} ${this.prefix ? `[${this.prefix}] ` : ""}${msg}${sessionInfo}`);
+			if (data && shouldLog(level)) console.dir(data, { depth: null });
+		}
+	}
+	info(msg, data) {
+		this.log("info", this.emoji, msg, console.log, data);
+	}
+	debug(msg, data) {
+		this.log("debug", this.emoji, msg, console.debug, data);
+	}
+	success(msg, data) {
+		this.log("info", "✅", msg, console.log, data);
+	}
+	warn(msg, data) {
+		this.log("warn", "⚠️", msg, console.warn, data);
+	}
+	error(msg, detail) {
+		this.log("error", "❌", msg, console.error, detail);
+	}
+	scope(msg, data) {
+		this.log("debug", "🔹", msg, console.debug, data);
+	}
+	dir(data) {
+		if (shouldLog("debug")) {
+			this.log("debug", "📦", "Object:", console.debug);
+			console.dir(data, { depth: null });
+		}
+	}
+	time(label) {
+		const start = performance.now();
+		return { end: (data) => {
+			const duration = performance.now() - start;
+			this.info(`${label} completed in ${duration.toFixed(2)}ms`, data);
+		} };
+	}
+};
+var logger = new BaseLogger("", "ℹ️");
+var componentLogger = new BaseLogger("Component", "🧩");
+var hookLogger = new BaseLogger("Hook", "🪝");
+var animationLogger = new BaseLogger("Animation", "🎬");
+var eventLogger = new BaseLogger("Event", "⚡");
+var apiLogger = new BaseLogger("API", "🌐");
+var storageLogger = new BaseLogger("Storage", "💾");
+var utilsLogger = new BaseLogger("Utils", "🔧");
+var getCurrentLogLevel = () => currentLevel;
+var isDebugEnabled = () => shouldLog("debug");
+//#endregion
+//#region src/utils/common/noop.ts
+var noop = (..._args) => {};
+//#endregion
+//#region src/utils/conditional/is.ts
+var is = (type) => (x) => Object(x) instanceof type;
+//#endregion
+//#region src/utils/conditional/isNonNullable.ts
+var isNonNullable = (value) => value !== void 0 && value !== null;
+//#endregion
+//#region src/utils/conditional/notReachable.ts
+var notReachable = (arg) => {
+	throw new Error(`"${arg}" should never be reached`);
+};
+//#endregion
+//#region src/utils/object/keys.ts
+var keys = (value) => {
+	const primitiveKeys = Object.keys(value);
+	const symbolKeys = Object.getOwnPropertySymbols(value).filter((sym) => Object.getOwnPropertyDescriptor(value, sym)?.enumerable);
+	return [...primitiveKeys, ...symbolKeys];
+};
+//#endregion
+//#region src/utils/object/values.ts
+var values = (input) => {
+	return keys(input).map((key) => input[key]);
+};
+//#endregion
+export { move as C, times as S, setLogLevel as _, is as a, storageLogger as b, animationLogger as c, componentLogger as d, eventLogger as f, logger as g, isDebugEnabled as h, isNonNullable as i, apiLogger as l, hookLogger as m, keys as n, noop as o, getCurrentLogLevel as p, notReachable as r, BaseLogger as s, values as t, clearSession as u, setRequestId as v, utilsLogger as x, setSessionId as y };

package/dist/values-BqSJ0h9o.cjs

@@ -0,0 +1,275 @@
+//#region src/utils/array/move.ts
+var move = (source, start, end) => {
+	const item = source[start];
+	const result = source.slice(0);
+	result.splice(start, 1);
+	result.splice(end, 0, item);
+	return result;
+};
+//#endregion
+//#region src/utils/array/times.ts
+var times = (fn, size) => Array.from({ length: size }, (_, index) => fn(index));
+//#endregion
+//#region src/utils/common/logger.ts
+var logRank = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+var getEnvLogLevel = () => {
+	if (typeof process === "undefined") return "info";
+	const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+	return envLevel && Object.prototype.hasOwnProperty.call(logRank, envLevel) ? envLevel : "info";
+};
+var currentLevel = getEnvLogLevel();
+var setLogLevel = (level) => {
+	if (Object.prototype.hasOwnProperty.call(logRank, level)) currentLevel = level;
+};
+var getTimestamp = () => {
+	const now = /* @__PURE__ */ new Date();
+	return now.toTimeString().split(" ")[0] + "." + now.getMilliseconds().toString().padStart(3, "0");
+};
+var shouldLog = (level) => {
+	return logRank[level] <= logRank[currentLevel];
+};
+var sessionId = null;
+var requestId = null;
+var setSessionId = (id) => {
+	sessionId = id;
+};
+var setRequestId = (id) => {
+	requestId = id;
+};
+var clearSession = () => {
+	sessionId = null;
+	requestId = null;
+};
+var getSessionInfo = () => {
+	const parts = [];
+	if (sessionId) parts.push(`session:${sessionId}`);
+	if (requestId) parts.push(`req:${requestId}`);
+	return parts.length > 0 ? `[${parts.join("|")}]` : "";
+};
+var BaseLogger = class {
+	prefix;
+	emoji;
+	constructor(prefix, emoji) {
+		this.prefix = prefix;
+		this.emoji = emoji;
+	}
+	log(level, emoji, msg, fn = console.log, data) {
+		if (shouldLog(level)) {
+			const sessionInfo = getSessionInfo();
+			fn(`[${getTimestamp()}] ${emoji} ${this.prefix ? `[${this.prefix}] ` : ""}${msg}${sessionInfo}`);
+			if (data && shouldLog(level)) console.dir(data, { depth: null });
+		}
+	}
+	info(msg, data) {
+		this.log("info", this.emoji, msg, console.log, data);
+	}
+	debug(msg, data) {
+		this.log("debug", this.emoji, msg, console.debug, data);
+	}
+	success(msg, data) {
+		this.log("info", "✅", msg, console.log, data);
+	}
+	warn(msg, data) {
+		this.log("warn", "⚠️", msg, console.warn, data);
+	}
+	error(msg, detail) {
+		this.log("error", "❌", msg, console.error, detail);
+	}
+	scope(msg, data) {
+		this.log("debug", "🔹", msg, console.debug, data);
+	}
+	dir(data) {
+		if (shouldLog("debug")) {
+			this.log("debug", "📦", "Object:", console.debug);
+			console.dir(data, { depth: null });
+		}
+	}
+	time(label) {
+		const start = performance.now();
+		return { end: (data) => {
+			const duration = performance.now() - start;
+			this.info(`${label} completed in ${duration.toFixed(2)}ms`, data);
+		} };
+	}
+};
+var logger = new BaseLogger("", "ℹ️");
+var componentLogger = new BaseLogger("Component", "🧩");
+var hookLogger = new BaseLogger("Hook", "🪝");
+var animationLogger = new BaseLogger("Animation", "🎬");
+var eventLogger = new BaseLogger("Event", "⚡");
+var apiLogger = new BaseLogger("API", "🌐");
+var storageLogger = new BaseLogger("Storage", "💾");
+var utilsLogger = new BaseLogger("Utils", "🔧");
+var getCurrentLogLevel = () => currentLevel;
+var isDebugEnabled = () => shouldLog("debug");
+//#endregion
+//#region src/utils/common/noop.ts
+var noop = (..._args) => {};
+//#endregion
+//#region src/utils/conditional/is.ts
+var is = (type) => (x) => Object(x) instanceof type;
+//#endregion
+//#region src/utils/conditional/isNonNullable.ts
+var isNonNullable = (value) => value !== void 0 && value !== null;
+//#endregion
+//#region src/utils/conditional/notReachable.ts
+var notReachable = (arg) => {
+	throw new Error(`"${arg}" should never be reached`);
+};
+//#endregion
+//#region src/utils/object/keys.ts
+var keys = (value) => {
+	const primitiveKeys = Object.keys(value);
+	const symbolKeys = Object.getOwnPropertySymbols(value).filter((sym) => Object.getOwnPropertyDescriptor(value, sym)?.enumerable);
+	return [...primitiveKeys, ...symbolKeys];
+};
+//#endregion
+//#region src/utils/object/values.ts
+var values = (input) => {
+	return keys(input).map((key) => input[key]);
+};
+//#endregion
+Object.defineProperty(exports, "BaseLogger", {
+	enumerable: true,
+	get: function() {
+		return BaseLogger;
+	}
+});
+Object.defineProperty(exports, "animationLogger", {
+	enumerable: true,
+	get: function() {
+		return animationLogger;
+	}
+});
+Object.defineProperty(exports, "apiLogger", {
+	enumerable: true,
+	get: function() {
+		return apiLogger;
+	}
+});
+Object.defineProperty(exports, "clearSession", {
+	enumerable: true,
+	get: function() {
+		return clearSession;
+	}
+});
+Object.defineProperty(exports, "componentLogger", {
+	enumerable: true,
+	get: function() {
+		return componentLogger;
+	}
+});
+Object.defineProperty(exports, "eventLogger", {
+	enumerable: true,
+	get: function() {
+		return eventLogger;
+	}
+});
+Object.defineProperty(exports, "getCurrentLogLevel", {
+	enumerable: true,
+	get: function() {
+		return getCurrentLogLevel;
+	}
+});
+Object.defineProperty(exports, "hookLogger", {
+	enumerable: true,
+	get: function() {
+		return hookLogger;
+	}
+});
+Object.defineProperty(exports, "is", {
+	enumerable: true,
+	get: function() {
+		return is;
+	}
+});
+Object.defineProperty(exports, "isDebugEnabled", {
+	enumerable: true,
+	get: function() {
+		return isDebugEnabled;
+	}
+});
+Object.defineProperty(exports, "isNonNullable", {
+	enumerable: true,
+	get: function() {
+		return isNonNullable;
+	}
+});
+Object.defineProperty(exports, "keys", {
+	enumerable: true,
+	get: function() {
+		return keys;
+	}
+});
+Object.defineProperty(exports, "logger", {
+	enumerable: true,
+	get: function() {
+		return logger;
+	}
+});
+Object.defineProperty(exports, "move", {
+	enumerable: true,
+	get: function() {
+		return move;
+	}
+});
+Object.defineProperty(exports, "noop", {
+	enumerable: true,
+	get: function() {
+		return noop;
+	}
+});
+Object.defineProperty(exports, "notReachable", {
+	enumerable: true,
+	get: function() {
+		return notReachable;
+	}
+});
+Object.defineProperty(exports, "setLogLevel", {
+	enumerable: true,
+	get: function() {
+		return setLogLevel;
+	}
+});
+Object.defineProperty(exports, "setRequestId", {
+	enumerable: true,
+	get: function() {
+		return setRequestId;
+	}
+});
+Object.defineProperty(exports, "setSessionId", {
+	enumerable: true,
+	get: function() {
+		return setSessionId;
+	}
+});
+Object.defineProperty(exports, "storageLogger", {
+	enumerable: true,
+	get: function() {
+		return storageLogger;
+	}
+});
+Object.defineProperty(exports, "times", {
+	enumerable: true,
+	get: function() {
+		return times;
+	}
+});
+Object.defineProperty(exports, "utilsLogger", {
+	enumerable: true,
+	get: function() {
+		return utilsLogger;
+	}
+});
+Object.defineProperty(exports, "values", {
+	enumerable: true,
+	get: function() {
+		return values;
+	}
+});