@taiv/ui 1.15.0 → 2.0.0

package/dist/styles/iosInputZoomFix.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * iOS Safari auto-zooms when a focused form input has font-size < 16px AND
+ * the page's viewport allows zoom (`maximum-scale > 1`). Both conditions
+ * must hold; iOS evaluates them at focus time. We sidestep the zoom by
+ * temporarily setting `maximum-scale=1` on the viewport meta while the
+ * user is interacting with a text input, then restoring whatever was
+ * there before. The page's normal pinch-to-zoom remains available
+ * everywhere else.
+ *
+ * Why the viewport-swap approach over a CSS bump to 16px on mobile inputs:
+ * this preserves the toolkit's input typography exactly. No visual change
+ * at any breakpoint.
+ *
+ * **Why `pointerdown` and not `focusin`:** iOS commits the auto-zoom
+ * decision when focus is committed to the element, which happens BEFORE
+ * the DOM `focusin` event fires in our listener. Setting the viewport
+ * inside `focusin` is too late — iOS has already evaluated and queued
+ * the zoom animation. Listening on `pointerdown` (capture phase) lets
+ * us write the new viewport meta before the browser commits focus.
+ * `pointerdown` covers both touch and mouse uniformly.
+ *
+ * Composability with other viewport tweaks (e.g. `useEditorViewport` on
+ * the slide editor route): we capture the viewport content at lock time,
+ * not at module load. So whatever state the page is in when the user
+ * taps an input — default, slide-editor-locked, future overrides — is
+ * what we restore on blur. Setup-time capture would have stale state and
+ * clobber other modules that lock the viewport for their own reasons.
+ */
+const VIEWPORT_FOCUSED = 'width=device-width, initial-scale=1, maximum-scale=1';
+const setupIosInputZoomFix = () => {
+    // No-op on the server.
+    if (typeof document === 'undefined')
+        return;
+    const meta = document.querySelector('meta[name="viewport"]');
+    if (!meta)
+        return;
+    // Idempotency: a flag on the meta so HMR / multiple imports don't stack
+    // listeners. Using a DOM marker rather than a module-scoped boolean
+    // because side-effect imports can be re-evaluated by some bundler
+    // configurations during dev.
+    const ATTACHED = 'data-taiv-ios-zoom-fix';
+    if (meta.getAttribute(ATTACHED) === 'true')
+        return;
+    meta.setAttribute(ATTACHED, 'true');
+    // Per-focus snapshot. Captured on focusin, restored on focusout. Stored
+    // outside the listeners so paired events share state. `null` when no
+    // text input is currently focused.
+    let snapshot = null;
+    const isTextEntry = (target) => {
+        if (!(target instanceof HTMLElement))
+            return false;
+        const tag = target.tagName;
+        if (tag === 'TEXTAREA' || tag === 'SELECT')
+            return true;
+        if (tag !== 'INPUT')
+            return false;
+        // Excludes button-like input types that don't trigger iOS's auto-zoom
+        // (checkbox, radio, file, button, submit, etc.).
+        const type = target.type;
+        return (type !== 'checkbox' &&
+            type !== 'radio' &&
+            type !== 'button' &&
+            type !== 'submit' &&
+            type !== 'reset' &&
+            type !== 'file' &&
+            type !== 'image' &&
+            type !== 'hidden' &&
+            type !== 'range' &&
+            type !== 'color');
+    };
+    // `pointerdown` fires before the browser commits focus, so the viewport
+    // meta is in place by the time iOS evaluates whether to auto-zoom.
+    // Capture phase ensures we run before any consumer's pointerdown handlers
+    // that might call `stopPropagation()`. `passive: true` keeps scrolling
+    // smooth — we only read `target` and write the meta, never preventDefault.
+    //
+    // Resolving the input from `e.target` is two-step:
+    //   1. `closest('input, textarea, select')` walks up to the nearest
+    //      input ancestor — handles direct taps on the input itself.
+    //   2. If no ancestor input, walk up to a Mantine input wrapper and
+    //      look INSIDE for the input. Mantine renders trigger affordances
+    //      (chevron, clear button, search icon) as siblings of the input
+    //      under a shared wrapper; tapping those would otherwise miss the
+    //      lock because the input is a sibling, not an ancestor. This case
+    //      matters most for `<Select>` — the chevron and the input both
+    //      live under `.mantine-Input-wrapper`, and the chevron tap is
+    //      what programmatically focuses the input → iOS zooms without
+    //      our lock unless we catch the wrapper-level tap.
+    document.addEventListener('pointerdown', (e) => {
+        const target = e.target;
+        if (!(target instanceof Element))
+            return;
+        let field = target.closest('input, textarea, select');
+        if (!field) {
+            const wrapper = target.closest('.mantine-Input-wrapper, .mantine-InputWrapper-root');
+            if (wrapper) {
+                field = wrapper.querySelector('input, textarea, select');
+            }
+        }
+        if (!isTextEntry(field))
+            return;
+        // Only snapshot if we don't already have one — avoids overwriting on
+        // rapid pointerdown sequences (e.g. tap-and-drag) before focusout
+        // has a chance to clean up.
+        if (snapshot === null) {
+            snapshot = meta.getAttribute('content');
+        }
+        meta.setAttribute('content', VIEWPORT_FOCUSED);
+    }, { capture: true, passive: true });
+    // Restore on blur. focusout bubbles, focus does not — using focusout
+    // means a single document-level listener catches every input.
+    //
+    // Deferred restore (rAF), not synchronous: when the user taps straight
+    // from one text input to another, iOS fires focusout(A) BEFORE focusin(B),
+    // and `document.activeElement` is transiently `<body>` during the handoff.
+    // Restoring synchronously here would unlock the viewport in that gap —
+    // iOS then re-evaluates at focus-commit on B and zooms anyway. Deferring
+    // one frame lets focus settle, then we restore only if focus has truly
+    // left all text entries. If it landed on another input, we keep the lock
+    // and the original snapshot intact until focus leaves text entry for good.
+    document.addEventListener('focusout', (e) => {
+        if (!isTextEntry(e.target))
+            return;
+        requestAnimationFrame(() => {
+            if (snapshot === null)
+                return;
+            if (isTextEntry(document.activeElement))
+                return;
+            meta.setAttribute('content', snapshot);
+            snapshot = null;
+        });
+    });
+};
+setupIosInputZoomFix();

package/dist/utils/bytes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compact human-readable byte size: "512 B", "1.4 KB", "9.2 MB", "1.30 GB".
+ *
+ * Uses 1024 as the conversion base (binary), which matches what most
+ * file-system / asset-store consumers display. KB and MB precision is one
+ * decimal, GB precision is two decimals — matches the intuition that bigger
+ * units deserve finer granularity for the same screen footprint.
+ */
+export declare const formatBytes: (n: number) => string;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/utils/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/utils/bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,KAAG,MAKvC,CAAC"}

package/dist/utils/bytes.js

@@ -0,0 +1,17 @@
+/**
+ * Compact human-readable byte size: "512 B", "1.4 KB", "9.2 MB", "1.30 GB".
+ *
+ * Uses 1024 as the conversion base (binary), which matches what most
+ * file-system / asset-store consumers display. KB and MB precision is one
+ * decimal, GB precision is two decimals — matches the intuition that bigger
+ * units deserve finer granularity for the same screen footprint.
+ */
+export const formatBytes = (n) => {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / 1024 / 1024).toFixed(1)} MB`;
+    return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+};

package/dist/utils/datetime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compact "time-since" string with minute/hour granularity. Past-only —
+ * use this for "edited 5m ago", "uploaded 12h ago" style metadata where
+ * the value will never be in the future. Near-now and slightly-future
+ * inputs (clock skew) collapse to 'just now'.
+ *
+ * @param input     The timestamp to describe.
+ * @param reference The "now" to measure against. Defaults to the current
+ *                  time; pass an explicit value to make output deterministic
+ *                  in tests.
+ *
+ * @example
+ *   formatRelativeTime(thirtySecondsAgo) // 'just now'
+ *   formatRelativeTime(twelveHoursAgo)   // '12h ago'
+ *   formatRelativeTime(threeWeeksAgo)    // '3w ago'
+ */
+export declare const formatRelativeTime: (input: string | number | Date, reference?: string | number | Date) => string;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/utils/datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../src/utils/datetime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,GAAG,MAAM,GAAG,IAAI,EAC7B,YAAW,MAAM,GAAG,MAAM,GAAG,IAAiB,KAC7C,MAqBF,CAAC"}

package/dist/utils/datetime.js

@@ -0,0 +1,42 @@
+/**
+ * Compact "time-since" string with minute/hour granularity. Past-only —
+ * use this for "edited 5m ago", "uploaded 12h ago" style metadata where
+ * the value will never be in the future. Near-now and slightly-future
+ * inputs (clock skew) collapse to 'just now'.
+ *
+ * @param input     The timestamp to describe.
+ * @param reference The "now" to measure against. Defaults to the current
+ *                  time; pass an explicit value to make output deterministic
+ *                  in tests.
+ *
+ * @example
+ *   formatRelativeTime(thirtySecondsAgo) // 'just now'
+ *   formatRelativeTime(twelveHoursAgo)   // '12h ago'
+ *   formatRelativeTime(threeWeeksAgo)    // '3w ago'
+ */
+export const formatRelativeTime = (input, reference = new Date()) => {
+    const targetMs = input instanceof Date ? input.getTime() : new Date(input).getTime();
+    const refMs = reference instanceof Date ? reference.getTime() : new Date(reference).getTime();
+    if (Number.isNaN(targetMs) || Number.isNaN(refMs))
+        return '';
+    const diffSeconds = Math.floor((refMs - targetMs) / 1000);
+    if (diffSeconds < 60)
+        return 'just now';
+    const minutes = Math.floor(diffSeconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(days / 365);
+    return `${years}y ago`;
+};

package/dist/utils/duration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compact human-readable duration: "5.3s", "2m 35s", "1h 20m", "3h".
+ *
+ * Input is in **seconds** (not milliseconds). Callers should guard against
+ * zero, negative, NaN, and Infinity before calling — this function does not
+ * clamp or default those values.
+ *
+ * Precision rules:
+ *   - Sub-60s: one decimal place ("5.3s") — fine grain matters for short clips.
+ *   - 60s and above: whole seconds only, sub-second precision dropped ("2m 35s").
+ *
+ * No day unit — hours are the largest unit ("25h"). Suitable for content
+ * durations (slides, playlists, video clips) where values above a few hours
+ * are not expected.
+ */
+export declare const formatDuration: (seconds: number) => string;
+//# sourceMappingURL=duration.d.ts.map

package/dist/utils/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/utils/duration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MAiBhD,CAAC"}

package/dist/utils/duration.js

@@ -0,0 +1,30 @@
+/**
+ * Compact human-readable duration: "5.3s", "2m 35s", "1h 20m", "3h".
+ *
+ * Input is in **seconds** (not milliseconds). Callers should guard against
+ * zero, negative, NaN, and Infinity before calling — this function does not
+ * clamp or default those values.
+ *
+ * Precision rules:
+ *   - Sub-60s: one decimal place ("5.3s") — fine grain matters for short clips.
+ *   - 60s and above: whole seconds only, sub-second precision dropped ("2m 35s").
+ *
+ * No day unit — hours are the largest unit ("25h"). Suitable for content
+ * durations (slides, playlists, video clips) where values above a few hours
+ * are not expected.
+ */
+export const formatDuration = (seconds) => {
+    if (seconds < 60) {
+        const rounded = Math.round(seconds * 10) / 10;
+        return `${rounded}s`;
+    }
+    const totalSeconds = Math.round(seconds);
+    const m = Math.floor(totalSeconds / 60);
+    const s = totalSeconds % 60;
+    if (m >= 60) {
+        const h = Math.floor(m / 60);
+        const remainingM = m % 60;
+        return remainingM > 0 ? `${h}h ${remainingM}m` : `${h}h`;
+    }
+    return s > 0 ? `${m}m ${s}s` : `${m}m`;
+};

package/dist/utils/index.d.ts

@@ -1,3 +1,9 @@
-export { getOptionLabel, getOptionByValue, getCascadingOptionLabel } from './select';
-export { getChartFormatter, aggregateDataByDate } from './charts';
+export { formatBytes } from './bytes';
+export { aggregateDataByDate, getChartFormatter } from './charts';
+export { formatRelativeTime } from './datetime';
+export { formatDuration } from './duration';
+export { getCascadingOptionLabel, getOptionByValue, getOptionLabel, } from './select';
+export type { SortDirection } from './sort';
+export { byDate, byNumber, byString, sortBy, sortByCreated, sortByName, sortByUpdated, } from './sort';
+export { pluralize, quantify } from './string';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,aAAa,EACb,UAAU,EACV,aAAa,GACd,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC"}

package/dist/utils/index.js

@@ -1,2 +1,7 @@
-export { getOptionLabel, getOptionByValue, getCascadingOptionLabel } from './select';
-export { getChartFormatter, aggregateDataByDate } from './charts';
+export { formatBytes } from './bytes';
+export { aggregateDataByDate, getChartFormatter } from './charts';
+export { formatRelativeTime } from './datetime';
+export { formatDuration } from './duration';
+export { getCascadingOptionLabel, getOptionByValue, getOptionLabel, } from './select';
+export { byDate, byNumber, byString, sortBy, sortByCreated, sortByName, sortByUpdated, } from './sort';
+export { pluralize, quantify } from './string';

package/dist/utils/sort.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Reusable sort helpers. Two layers:
+ *
+ *   1. Convenience verbs (`sortByName`, `sortByCreated`, `sortByUpdated`) for the
+ *      shared fields most domain objects carry. Callsites pass a list + direction
+ *      and never write a comparator: `sortByUpdated(slides, 'desc')`.
+ *
+ *   2. Comparator primitives (`byString`, `byNumber`, `byDate`) + a non-mutating
+ *      `sortBy(items, ...comparators)` for fields the verbs don't cover (e.g.
+ *      `byNumber(p => p.slides.length)`) or multi-key sorts with tiebreakers.
+ *
+ * All comparators centralize the fiddly bits once: nullish coalescing, a pinned
+ * `'en'` locale for stable string ordering across browsers/OSes, and Date
+ * parsing with a NaN guard (unparseable / missing dates sort as epoch 0).
+ */
+export type SortDirection = 'asc' | 'desc';
+type DateLike = string | number | Date | null | undefined;
+export declare const byString: <T>(get: (item: T) => string | null | undefined, dir?: SortDirection) => (a: T, b: T) => number;
+export declare const byNumber: <T>(get: (item: T) => number | null | undefined, dir?: SortDirection) => (a: T, b: T) => number;
+export declare const byDate: <T>(get: (item: T) => DateLike, dir?: SortDirection) => (a: T, b: T) => number;
+export declare const sortBy: <T>(items: readonly T[], ...comparators: Array<(a: T, b: T) => number>) => T[];
+/** Sort by display name. Resolves `name → title → label` so it covers both
+ *  domain objects and `Select`-style `{ value, label }` options. */
+export declare const sortByName: <T extends {
+    name?: string | null;
+    title?: string | null;
+    label?: string | null;
+}>(items: readonly T[], dir?: SortDirection) => T[];
+/** Sort by creation time. Resolves `created → createdAt`. */
+export declare const sortByCreated: <T extends {
+    created?: DateLike;
+    createdAt?: DateLike;
+}>(items: readonly T[], dir?: SortDirection) => T[];
+/** Sort by last-updated time. Resolves `edited → updated → updatedAt`, falling
+ *  back to `created → createdAt` so never-edited items still sort sensibly. */
+export declare const sortByUpdated: <T extends {
+    edited?: DateLike;
+    updated?: DateLike;
+    updatedAt?: DateLike;
+    created?: DateLike;
+    createdAt?: DateLike;
+}>(items: readonly T[], dir?: SortDirection) => T[];
+export {};
+//# sourceMappingURL=sort.d.ts.map

package/dist/utils/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/utils/sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAE3C,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;AAsB1D,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,MAAK,aAAqB,MAC1E,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,MACiC,CAAC;AAElD,eAAO,MAAM,QAAQ,GAClB,CAAC,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,MAAK,aAAqB,MAC1E,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,MACkC,CAAC;AAEnD,eAAO,MAAM,MAAM,GAChB,CAAC,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,QAAQ,EAAE,MAAK,aAAqB,MACzD,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,MACoC,CAAC;AAMrD,eAAO,MAAM,MAAM,GAAI,CAAC,EACtB,OAAO,SAAS,CAAC,EAAE,EACnB,GAAG,aAAa,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,KAC5C,CAAC,EAOA,CAAC;AAIL;oEACoE;AACpE,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS;IACR,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,EAED,OAAO,SAAS,CAAC,EAAE,EACnB,MAAK,aAAqB,KACzB,CAAC,EAAuE,CAAC;AAE5E,6DAA6D;AAC7D,eAAO,MAAM,aAAa,GACxB,CAAC,SAAS;IAAE,OAAO,CAAC,EAAE,QAAQ,CAAC;IAAC,SAAS,CAAC,EAAE,QAAQ,CAAA;CAAE,EAEtD,OAAO,SAAS,CAAC,EAAE,EACnB,MAAK,aAAqB,KACzB,CAAC,EAAiE,CAAC;AAEtE;+EAC+E;AAC/E,eAAO,MAAM,aAAa,GACxB,CAAC,SAAS;IACR,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,SAAS,CAAC,EAAE,QAAQ,CAAC;CACtB,EAED,OAAO,SAAS,CAAC,EAAE,EACnB,MAAK,aAAqB,KACzB,CAAC,EAOD,CAAC"}

package/dist/utils/sort.js

@@ -0,0 +1,53 @@
+/**
+ * Reusable sort helpers. Two layers:
+ *
+ *   1. Convenience verbs (`sortByName`, `sortByCreated`, `sortByUpdated`) for the
+ *      shared fields most domain objects carry. Callsites pass a list + direction
+ *      and never write a comparator: `sortByUpdated(slides, 'desc')`.
+ *
+ *   2. Comparator primitives (`byString`, `byNumber`, `byDate`) + a non-mutating
+ *      `sortBy(items, ...comparators)` for fields the verbs don't cover (e.g.
+ *      `byNumber(p => p.slides.length)`) or multi-key sorts with tiebreakers.
+ *
+ * All comparators centralize the fiddly bits once: nullish coalescing, a pinned
+ * `'en'` locale for stable string ordering across browsers/OSes, and Date
+ * parsing with a NaN guard (unparseable / missing dates sort as epoch 0).
+ */
+const dirSign = (dir) => (dir === 'desc' ? -1 : 1);
+const toTime = (v) => {
+    if (v == null)
+        return 0;
+    const t = v instanceof Date ? v.getTime() : new Date(v).getTime();
+    return Number.isFinite(t) ? t : 0;
+};
+// Case-insensitive, locale-stable. Pinned to 'en' rather than the runtime
+// default so ordering is identical across browsers/OSes (Turkish-i, German-ß,
+// etc. otherwise diverge).
+const compareStrings = (a, b) => (a !== null && a !== void 0 ? a : '').localeCompare(b !== null && b !== void 0 ? b : '', 'en', { sensitivity: 'base' });
+// ── Comparator primitives ──────────────────────────────────────────────────
+// Each takes an accessor + direction and returns a comparator. Compose them
+// with `sortBy` for custom fields, multi-key sorts, or tiebreakers.
+export const byString = (get, dir = 'asc') => (a, b) => dirSign(dir) * compareStrings(get(a), get(b));
+export const byNumber = (get, dir = 'asc') => (a, b) => { var _a, _b; return dirSign(dir) * (((_a = get(a)) !== null && _a !== void 0 ? _a : 0) - ((_b = get(b)) !== null && _b !== void 0 ? _b : 0)); };
+export const byDate = (get, dir = 'asc') => (a, b) => dirSign(dir) * (toTime(get(a)) - toTime(get(b)));
+// ── Non-mutating, multi-key sort ─────────────────────────────────────────────
+// Returns a new array. Comparators are applied in order; the first non-zero
+// result wins, so trailing comparators act as tiebreakers:
+//   sortBy(users, byBoolean(u => u.isSelf, 'desc'), byString(u => u.name))
+export const sortBy = (items, ...comparators) => [...items].sort((a, b) => {
+    for (const cmp of comparators) {
+        const result = cmp(a, b);
+        if (result !== 0)
+            return result;
+    }
+    return 0;
+});
+// ── Convenience verbs for common shared fields ───────────────────────────────
+/** Sort by display name. Resolves `name → title → label` so it covers both
+ *  domain objects and `Select`-style `{ value, label }` options. */
+export const sortByName = (items, dir = 'asc') => sortBy(items, byString((i) => { var _a, _b; return (_b = (_a = i.name) !== null && _a !== void 0 ? _a : i.title) !== null && _b !== void 0 ? _b : i.label; }, dir));
+/** Sort by creation time. Resolves `created → createdAt`. */
+export const sortByCreated = (items, dir = 'asc') => sortBy(items, byDate((i) => { var _a; return (_a = i.created) !== null && _a !== void 0 ? _a : i.createdAt; }, dir));
+/** Sort by last-updated time. Resolves `edited → updated → updatedAt`, falling
+ *  back to `created → createdAt` so never-edited items still sort sensibly. */
+export const sortByUpdated = (items, dir = 'asc') => sortBy(items, byDate((i) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = i.edited) !== null && _a !== void 0 ? _a : i.updated) !== null && _b !== void 0 ? _b : i.updatedAt) !== null && _c !== void 0 ? _c : i.created) !== null && _d !== void 0 ? _d : i.createdAt; }, dir));

package/dist/utils/string.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns the singular form when `count` is 1, otherwise the plural.
+ * If no explicit plural is provided, appends `s` to the singular.
+ *
+ * @example
+ *   pluralize('item', 1)             // 'item'
+ *   pluralize('item', 3)             // 'items'
+ *   pluralize('child', 2, 'children') // 'children'
+ */
+export declare const pluralize: (word: string, count: number, plural?: string) => string;
+/**
+ * Like {@link pluralize}, but prefixes the count — the common "{n} things"
+ * phrasing. Forwards the optional custom plural.
+ *
+ * @example
+ *   quantify('item', 1)                          // '1 item'
+ *   quantify('item', 3)                          // '3 items'
+ *   quantify('item', 0)                          // '0 items'
+ *   quantify('subcategory', 2, 'subcategories')  // '2 subcategories'
+ */
+export declare const quantify: (word: string, count: number, plural?: string) => string;
+//# sourceMappingURL=string.d.ts.map

package/dist/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GACpB,MAAM,MAAM,EACZ,OAAO,MAAM,EACb,SAAS,MAAM,KACd,MAGF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GACnB,MAAM,MAAM,EACZ,OAAO,MAAM,EACb,SAAS,MAAM,KACd,MAAsD,CAAC"}

package/dist/utils/string.js

@@ -0,0 +1,25 @@
+/**
+ * Returns the singular form when `count` is 1, otherwise the plural.
+ * If no explicit plural is provided, appends `s` to the singular.
+ *
+ * @example
+ *   pluralize('item', 1)             // 'item'
+ *   pluralize('item', 3)             // 'items'
+ *   pluralize('child', 2, 'children') // 'children'
+ */
+export const pluralize = (word, count, plural) => {
+    if (count === 1)
+        return word;
+    return plural !== null && plural !== void 0 ? plural : `${word}s`;
+};
+/**
+ * Like {@link pluralize}, but prefixes the count — the common "{n} things"
+ * phrasing. Forwards the optional custom plural.
+ *
+ * @example
+ *   quantify('item', 1)                          // '1 item'
+ *   quantify('item', 3)                          // '3 items'
+ *   quantify('item', 0)                          // '0 items'
+ *   quantify('subcategory', 2, 'subcategories')  // '2 subcategories'
+ */
+export const quantify = (word, count, plural) => `${count} ${pluralize(word, count, plural)}`;

package/package.json

@@ -2,13 +2,30 @@
   "author": "Taiv",
   "dependencies": {
     "@emotion/react": "^11.14.0",
+    "@mantine/carousel": "^6.0.22",
     "@mantine/core": "^6.0.0",
     "@mantine/dates": "^6.0.22",
+    "@mantine/dropzone": "^6.0.22",
+    "@mantine/form": "^6.0.22",
     "@mantine/hooks": "^6.0.0",
     "@mantine/modals": "^6.0.0",
     "@mantine/notifications": "^6.0.0",
+    "@preact/signals": "^2.0.2",
+    "@schedule-x/calendar": "^2.36.0",
+    "@schedule-x/current-time": "^2.36.0",
+    "@schedule-x/drag-and-drop": "^2.36.0",
+    "@schedule-x/events-service": "^2.36.0",
+    "@schedule-x/react": "^2.36.0",
+    "@schedule-x/resize": "^2.36.0",
+    "@schedule-x/theme-default": "^2.36.0",
     "@tabler/icons-react": "^3.41.1",
+    "@types/react-big-calendar": "^0.33.2",
     "dayjs": "^1.11.18",
+    "embla-carousel-autoplay": "^7.1.0",
+    "embla-carousel-react": "^7.1.0",
+    "preact": "^10.19.2",
+    "react-big-calendar": "^0.38.9",
+    "react-virtuoso": "^4.18.7",
     "recharts": "^2.8.0"
   },
   "description": "Taiv's web UI Toolkit built on Mantine v6",
@@ -25,6 +42,12 @@
   },
   "exports": {
     ".": "./dist/components/index.js",
+    "./assets": {
+      "default": "./dist/assets/index.js",
+      "import": "./dist/assets/index.js",
+      "types": "./dist/assets/index.d.ts"
+    },
+    "./assets/*": "./dist/assets/*",
     "./constants": "./dist/constants/index.js",
     "./hooks": "./dist/hooks/index.js",
     "./types": "./dist/types/index.js",
@@ -50,8 +73,9 @@
     "biome:check:path": "biome check",
     "biome:fix": "biome check --write src",
     "biome:fix:path": "biome check --write",
-    "build": "tsc",
+    "build": "tsc && npm run build:assets",
     "build-storybook": "storybook build",
+    "build:assets": "mkdir -p dist/assets/brand && cp -R src/assets/brand/. dist/assets/brand/",
     "clean": "rm -rf dist",
     "dev": "npm link && tsc --watch",
     "format": "biome check --linter-enabled=false --assist-enabled=false src",
@@ -61,5 +85,5 @@
     "storybook": "storybook dev -p 6006"
   },
   "types": "dist/index.d.ts",
-  "version": "1.15.0"
+  "version": "2.0.0"
 }