@urbicon-ui/blocks 6.34.0 → 6.36.0

package/dist/primitives/Toast/Toaster.svelte

@@ -12,7 +12,8 @@
   import WarningTriangleIconDefault from '../../icons/WarningTriangleIcon.svelte';
   import DangerCircleIconDefault from '../../icons/DangerCircleIcon.svelte';
   import { getBlocksConfig, resolveSlotClasses } from '../../provider';
-  import Spinner from '../Spinner/Spinner.svelte';
+  // internal core, not the public component — keeps the public-to-public import graph clean (see internal/core/)
+  import CoreSpinner from '../../internal/core/CoreSpinner.svelte';
   import type { ToastData, ToastProps } from './index';
 
   const bt = useBlocksI18n();
@@ -220,7 +221,21 @@
       transition:fly={flyParams()}
     >
       {#if toast.loading}
-        <span class={slot('icon', toast.intent)}><Spinner size="sm" /></span>
+        <!--
+          CoreSpinner instead of the public Spinner (see internal/core/).
+          Deliberate a11y delta: the old embedded Spinner emitted role="status" +
+          aria-live + an sr-only "Loading..." label — a live region NESTED inside
+          the toast's own role="alert" region. The core emits no semantics; the
+          toast region owns the announcement. `text-primary` pins the old look:
+          the public Spinner's intent DEFAULTED to primary, so the loading glyph
+          always rendered primary regardless of the toast intent (whether it
+          should follow the intent instead is logged in technical-debt.md). It
+          wins the color duel against the core's `text-current` by stylesheet
+          order (theme color utilities sort after keyword colors).
+        -->
+        <span class={slot('icon', toast.intent)}
+          ><CoreSpinner size="sm" class="text-primary" /></span
+        >
       {:else}
         <IntentIcon class={slot('icon', toast.intent)} />
       {/if}

package/dist/primitives/index.d.ts

@@ -55,6 +55,8 @@ export type { SliderMark, SliderProps } from './Slider/index.js';
 export * from './Slider/index.js';
 export type { SpinnerProps } from './Spinner/index.js';
 export * from './Spinner/index.js';
+export type { SplitPaneProps } from './SplitPane/index.js';
+export * from './SplitPane/index.js';
 export type { StepperProps, StepperStepProps } from './Stepper/index.js';
 export * from './Stepper/index.js';
 export type { TabItemProps, TabPanelProps, TabProps } from './Tab/index.js';

package/dist/primitives/index.js

@@ -29,6 +29,7 @@ export * from './Sidebar/index.js';
 export * from './Skeleton/index.js';
 export * from './Slider/index.js';
 export * from './Spinner/index.js';
+export * from './SplitPane/index.js';
 export * from './Stepper/index.js';
 export * from './Tab/index.js';
 export * from './Textarea/index.js';

package/dist/utils/file-intake.d.ts

@@ -0,0 +1,78 @@
+export type FileIntakeErrorCode = 'FILE_INVALID_TYPE' | 'FILE_TOO_LARGE' | 'FILE_TOO_SMALL' | 'TOO_MANY_FILES' | 'FILE_EXISTS' | 'CUSTOM';
+export interface FileIntakeError {
+    /** Machine-readable error code. */
+    code: FileIntakeErrorCode;
+    /** Human-readable error message. */
+    message: string;
+}
+export type FileIntakeStatus = 'pending' | 'uploading' | 'complete' | 'error';
+export interface FileIntakeEntry {
+    /** Unique identifier for this file entry. */
+    id: string;
+    /** The native File object. */
+    file: File;
+    /** Object URL for image previews (auto-generated, auto-revoked). */
+    preview?: string;
+    /** Upload progress 0–100. Undefined when not tracking. */
+    progress?: number;
+    /** Current lifecycle status. */
+    status: FileIntakeStatus;
+    /** Validation or upload errors. */
+    errors: FileIntakeError[];
+}
+export interface FileIntakeRejection {
+    /** The rejected file. */
+    file: File;
+    /** Why it was rejected. */
+    errors: FileIntakeError[];
+}
+/** Validation limits shared by every intake surface. */
+export interface FileIntakeConstraints {
+    /** Accepted MIME types or file extensions (e.g. 'image/*', '.pdf'). */
+    accept?: string | string[];
+    /** Maximum number of files across the whole list. */
+    maxFiles?: number;
+    /** Maximum file size in bytes. */
+    maxFileSize?: number;
+    /** Minimum file size in bytes. */
+    minFileSize?: number;
+    /** Custom validation function. Return errors array or null. */
+    validate?: (file: File) => FileIntakeError[] | null;
+}
+/** Error-text factories — components inject their i18n/label source here. */
+export interface FileIntakeMessages {
+    invalidType: (type: string) => string;
+    tooLarge: (formattedSize: string) => string;
+    tooSmall: (formattedSize: string) => string;
+    exists: () => string;
+    tooMany: (count: number) => string;
+}
+/** Does a picked/dropped file match the accept spec (`.ext`, `type/*`, exact MIME)? */
+export declare function matchesAccept(file: File, accept: string | string[] | undefined): boolean;
+/**
+ * Dragged-over feedback: do ALL items look acceptable? Extension patterns
+ * (`.pdf`) match permissively — file names are unavailable during dragenter,
+ * so a definitive verdict only exists for MIME patterns.
+ */
+export declare function dragItemsMatchAccept(items: Iterable<DataTransferItem>, accept: string | string[] | undefined): boolean;
+/** Validate one file against the constraints and the existing list (duplicates). */
+export declare function validateIntakeFile(file: File, existing: readonly FileIntakeEntry[], constraints: FileIntakeConstraints, messages: FileIntakeMessages): FileIntakeError[];
+/**
+ * Split incoming files into accepted entries (id + pending status + image
+ * preview object-URL) and rejections. Files beyond the remaining `maxFiles`
+ * budget are rejected with `TOO_MANY_FILES` before any validation runs.
+ * The caller owns the returned entries — including revoking their previews
+ * (`revokeIntakePreviews`) when they leave the list.
+ */
+export declare function partitionIntake(incoming: readonly File[], existing: readonly FileIntakeEntry[], constraints: FileIntakeConstraints, messages: FileIntakeMessages, idPrefix?: string): {
+    accepted: FileIntakeEntry[];
+    rejected: FileIntakeRejection[];
+};
+/** Wrap a (pre-validated) file as a pending entry with id and image preview. */
+export declare function createIntakeEntry(file: File, idPrefix?: string): FileIntakeEntry;
+/** Revoke the preview object-URLs of the given entries (removal/teardown). */
+export declare function revokeIntakePreviews(entries: Iterable<FileIntakeEntry>): void;
+/** Human-readable file size (`1.5 MB`). Empty string for non-finite values. */
+export declare function formatFileSize(bytes: number): string;
+/** Is this file an image (drives preview object-URL creation)? */
+export declare function isImageFile(file: File): boolean;

package/dist/utils/file-intake.js

@@ -0,0 +1,144 @@
+// Shared file-intake core — the pure logic behind FileUpload's dropzone and
+// PromptInput's attachment strip: accept matching, validation, accepted/
+// rejected partitioning, preview object-URL lifecycle, size formatting.
+//
+// Deliberately stateless functions, not a store class: both consumers keep
+// their own `$state`/`$bindable` file lists (FileUpload's `bind:files` must
+// stay the single source of truth there), and pure functions are node-testable
+// without a DOM. Error texts are injected via `FileIntakeMessages` so each
+// component keeps its own i18n/label wiring.
+// ── Accept matching ──────────────────────────────────────────────────────────
+function acceptList(accept) {
+    return Array.isArray(accept) ? accept : accept.split(',').map((t) => t.trim());
+}
+/** Does a picked/dropped file match the accept spec (`.ext`, `type/*`, exact MIME)? */
+export function matchesAccept(file, accept) {
+    if (!accept)
+        return true;
+    return acceptList(accept).some((type) => {
+        if (type.startsWith('.'))
+            return file.name.toLowerCase().endsWith(type.toLowerCase());
+        if (type.endsWith('/*'))
+            return file.type.startsWith(type.replace('/*', '/'));
+        return file.type === type;
+    });
+}
+/**
+ * Dragged-over feedback: do ALL items look acceptable? Extension patterns
+ * (`.pdf`) match permissively — file names are unavailable during dragenter,
+ * so a definitive verdict only exists for MIME patterns.
+ */
+export function dragItemsMatchAccept(items, accept) {
+    if (!accept)
+        return true;
+    const types = acceptList(accept);
+    return Array.from(items).every((item) => {
+        if (item.kind !== 'file')
+            return false;
+        return types.some((type) => {
+            if (type.endsWith('/*'))
+                return item.type.startsWith(type.replace('/*', '/'));
+            if (type.startsWith('.'))
+                return true;
+            return item.type === type;
+        });
+    });
+}
+// ── Validation & partitioning ────────────────────────────────────────────────
+/** Validate one file against the constraints and the existing list (duplicates). */
+export function validateIntakeFile(file, existing, constraints, messages) {
+    const errors = [];
+    const { accept, maxFileSize = Infinity, minFileSize = 0, validate } = constraints;
+    if (accept && !matchesAccept(file, accept)) {
+        errors.push({
+            code: 'FILE_INVALID_TYPE',
+            message: messages.invalidType(file.type || 'unknown')
+        });
+    }
+    if (file.size > maxFileSize) {
+        errors.push({
+            code: 'FILE_TOO_LARGE',
+            message: messages.tooLarge(formatFileSize(maxFileSize))
+        });
+    }
+    if (file.size < minFileSize) {
+        errors.push({
+            code: 'FILE_TOO_SMALL',
+            message: messages.tooSmall(formatFileSize(minFileSize))
+        });
+    }
+    if (existing.some((f) => f.file.name === file.name && f.file.size === file.size)) {
+        errors.push({ code: 'FILE_EXISTS', message: messages.exists() });
+    }
+    if (validate) {
+        const custom = validate(file);
+        if (custom)
+            errors.push(...custom);
+    }
+    return errors;
+}
+let idCounter = 0;
+/**
+ * Split incoming files into accepted entries (id + pending status + image
+ * preview object-URL) and rejections. Files beyond the remaining `maxFiles`
+ * budget are rejected with `TOO_MANY_FILES` before any validation runs.
+ * The caller owns the returned entries — including revoking their previews
+ * (`revokeIntakePreviews`) when they leave the list.
+ */
+export function partitionIntake(incoming, existing, constraints, messages, idPrefix = 'file') {
+    const accepted = [];
+    const rejected = [];
+    const maxFiles = constraints.maxFiles ?? Infinity;
+    const remaining = maxFiles - existing.length;
+    const toProcess = incoming.slice(0, Math.max(0, remaining));
+    const excess = incoming.slice(Math.max(0, remaining));
+    for (const file of excess) {
+        rejected.push({
+            file,
+            errors: [{ code: 'TOO_MANY_FILES', message: messages.tooMany(maxFiles) }]
+        });
+    }
+    for (const file of toProcess) {
+        const errors = validateIntakeFile(file, existing, constraints, messages);
+        if (errors.length > 0) {
+            rejected.push({ file, errors });
+        }
+        else {
+            accepted.push(createIntakeEntry(file, idPrefix));
+        }
+    }
+    return { accepted, rejected };
+}
+/** Wrap a (pre-validated) file as a pending entry with id and image preview. */
+export function createIntakeEntry(file, idPrefix = 'file') {
+    return {
+        id: `${idPrefix}-${Date.now()}-${++idCounter}`,
+        file,
+        status: 'pending',
+        errors: [],
+        preview: isImageFile(file) ? URL.createObjectURL(file) : undefined
+    };
+}
+/** Revoke the preview object-URLs of the given entries (removal/teardown). */
+export function revokeIntakePreviews(entries) {
+    for (const entry of entries) {
+        if (entry.preview)
+            URL.revokeObjectURL(entry.preview);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/** Human-readable file size (`1.5 MB`). Empty string for non-finite values. */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    if (!Number.isFinite(bytes))
+        return '';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+}
+/** Is this file an image (drives preview object-URL creation)? */
+export function isImageFile(file) {
+    return file.type.startsWith('image/');
+}

package/dist/utils/index.d.ts

@@ -1,6 +1,7 @@
 export * from './date.js';
 export * from './draggable.js';
 export * from './figma-token-export.js';
+export { createIntakeEntry, dragItemsMatchAccept, type FileIntakeConstraints, type FileIntakeEntry, type FileIntakeError, type FileIntakeErrorCode, type FileIntakeMessages, type FileIntakeRejection, type FileIntakeStatus, formatFileSize, isImageFile, matchesAccept, partitionIntake, revokeIntakePreviews, validateIntakeFile } from './file-intake.js';
 export { arrow, autoUpdate, type ComputePositionReturn, computePosition, flip, type Middleware, offset, type Placement, type Strategy, shift, size } from './floating.js';
 export { createBrowserNavigationSource, createLocalStorageAdapter, GuideController, type GuideControllerOptions, type GuideDirection, type GuideEndEvent, type GuideNavigationSource, type GuideOverlayStackLike, type GuideStep, type GuideStepEvent, type GuideStorageAdapter, type GuideTopicMeta, type GuideTour } from './guide.svelte.js';
 export * from './id.js';

package/dist/utils/index.js

@@ -1,6 +1,7 @@
 export * from './date.js';
 export * from './draggable.js';
 export * from './figma-token-export.js';
+export { createIntakeEntry, dragItemsMatchAccept, formatFileSize, isImageFile, matchesAccept, partitionIntake, revokeIntakePreviews, validateIntakeFile } from './file-intake.js';
 export { arrow, autoUpdate, computePosition, flip, offset, shift, size } from './floating.js';
 export { createBrowserNavigationSource, createLocalStorageAdapter, GuideController } from './guide.svelte.js';
 export * from './id.js';

package/dist/utils/variants.js

@@ -623,6 +623,20 @@ function resolveClassValue(value) {
  * time layer (ValidSlotVariants, VariantPropsMap) catches the same class of
  * mistakes for literal configs; this covers JS consumers and values built
  * from imported constants.
+ *
+ * Error codes (prod builds throw the bare code to keep message bytes out of
+ * consumer bundles; reproduce in dev for the full message. Codes are stable —
+ * never renumber, append only):
+ * - tv:E1  — `base` and `slots` are mutually exclusive
+ * - tv:E2  — plain class value routes to 'base', but no 'base' slot is declared
+ * - tv:E3  — class leaf is not a string / nested array of strings
+ * - tv:E4  — slot map given, but this tv() declares no slots
+ * - tv:E5  — value targets an undeclared slot name
+ * - tv:E6  — value is neither class string, array nor slot map
+ * - tv:E7  — compoundVariants references an unknown variant axis
+ * - tv:E8  — compoundVariants matches a value the axis does not declare
+ * - tv:E9  — defaultVariants references an unknown variant axis
+ * - tv:E10 — defaultVariants value is not declared on its axis
  */
 function validateTvConfig(config) {
     const { base, slots, variants = {}, compoundVariants = [], defaultVariants = {} } = config;
@@ -630,11 +644,15 @@ function validateTvConfig(config) {
     if (slotNames && base != null) {
         // Fail loud instead of the historical silent drop (base only ever
         // reached a slot literally named 'base').
-        throw new Error('tv(): `base` and `slots` are mutually exclusive — declare the primary slot as `slots.base` instead.');
+        throw new Error(import.meta.env?.DEV
+            ? 'tv(): `base` and `slots` are mutually exclusive — declare the primary slot as `slots.base` instead.'
+            : 'tv:E1');
     }
     const requireBaseSlot = (context) => {
         if (slotNames && !slotNames.includes('base')) {
-            throw new Error(`tv(): ${context} is a plain class value, which routes to the 'base' slot — but no slot named 'base' is declared.`);
+            throw new Error(import.meta.env?.DEV
+                ? `tv(): ${context} is a plain class value, which routes to the 'base' slot — but no slot named 'base' is declared.`
+                : 'tv:E2');
         }
     };
     // Leaf values must bottom out in class strings (nested arrays allowed,
@@ -652,7 +670,9 @@ function validateTvConfig(config) {
             }
             return;
         }
-        throw new Error(`tv(): ${context} must be a class string (or nested array of strings), got ${typeof value}.`);
+        throw new Error(import.meta.env?.DEV
+            ? `tv(): ${context} must be a class string (or nested array of strings), got ${typeof value}.`
+            : 'tv:E3');
     };
     const checkSlotKeys = (value, context) => {
         if (value == null)
@@ -665,17 +685,23 @@ function validateTvConfig(config) {
         }
         if (typeof value === 'object') {
             if (!slotNames) {
-                throw new Error(`tv(): ${context} is a slot map, but this tv() declares no slots — use a plain class string/array.`);
+                throw new Error(import.meta.env?.DEV
+                    ? `tv(): ${context} is a slot map, but this tv() declares no slots — use a plain class string/array.`
+                    : 'tv:E4');
             }
             for (const key of Object.keys(value)) {
                 if (!slotNames.includes(key)) {
-                    throw new Error(`tv(): ${context} targets unknown slot '${key}' (declared slots: ${slotNames.join(', ')}).`);
+                    throw new Error(import.meta.env?.DEV
+                        ? `tv(): ${context} targets unknown slot '${key}' (declared slots: ${slotNames.join(', ')}).`
+                        : 'tv:E5');
                 }
                 checkClassLeaf(value[key], `${context}.${key}`);
             }
             return;
         }
-        throw new Error(`tv(): ${context} must be a class string, array or slot map, got ${typeof value}.`);
+        throw new Error(import.meta.env?.DEV
+            ? `tv(): ${context} must be a class string, array or slot map, got ${typeof value}.`
+            : 'tv:E6');
     };
     for (const [axis, values] of Object.entries(variants)) {
         for (const [valueName, value] of Object.entries(values)) {
@@ -688,7 +714,9 @@ function validateTvConfig(config) {
                 continue;
             const axis = variants[key];
             if (axis == null) {
-                throw new Error(`tv(): compoundVariants[${i}] references unknown variant axis '${key}'.`);
+                throw new Error(import.meta.env?.DEV
+                    ? `tv(): compoundVariants[${i}] references unknown variant axis '${key}'.`
+                    : 'tv:E7');
             }
             const constraint = cv[key];
             const values = Array.isArray(constraint) ? constraint : [constraint];
@@ -703,7 +731,9 @@ function validateTvConfig(config) {
                 if ((normalized === 'true' || normalized === 'false') && booleanAxis)
                     continue;
                 if (normalized == null || !(normalized in axis)) {
-                    throw new Error(`tv(): compoundVariants[${i}] matches '${key}: ${String(v)}', but axis '${key}' declares no such value (values: ${Object.keys(axis).join(', ')}).`);
+                    throw new Error(import.meta.env?.DEV
+                        ? `tv(): compoundVariants[${i}] matches '${key}: ${String(v)}', but axis '${key}' declares no such value (values: ${Object.keys(axis).join(', ')}).`
+                        : 'tv:E8');
                 }
             }
         }
@@ -712,14 +742,18 @@ function validateTvConfig(config) {
     for (const [key, value] of Object.entries(defaultVariants)) {
         const axis = variants[key];
         if (axis == null) {
-            throw new Error(`tv(): defaultVariants references unknown variant axis '${key}'.`);
+            throw new Error(import.meta.env?.DEV
+                ? `tv(): defaultVariants references unknown variant axis '${key}'.`
+                : 'tv:E9');
         }
         const normalized = falsyToString(value);
         const booleanAxis = 'true' in axis || 'false' in axis;
         if ((normalized === 'true' || normalized === 'false') && booleanAxis)
             continue;
         if (normalized == null || !(normalized in axis)) {
-            throw new Error(`tv(): defaultVariants.${key} = '${String(value)}' is not a declared value of axis '${key}' (values: ${Object.keys(axis).join(', ')}).`);
+            throw new Error(import.meta.env?.DEV
+                ? `tv(): defaultVariants.${key} = '${String(value)}' is not a declared value of axis '${key}' (values: ${Object.keys(axis).join(', ')}).`
+                : 'tv:E10');
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urbicon-ui/blocks",
-  "version": "6.34.0",
+  "version": "6.36.0",
   "description": "Svelte 5 UI component library with Tailwind CSS 4, OKLCH design tokens and zero runtime dependencies",
   "license": "MIT",
   "repository": {
@@ -79,9 +79,7 @@
   },
   "sideEffects": [
     "./src/**/*.css",
-    "./dist/**/*.css",
-    "./dist/i18n/index.js",
-    "./dist/i18n/index.d.ts"
+    "./dist/**/*.css"
   ],
   "peerDependencies": {
     "svelte": "^5.56.4",
@@ -95,8 +93,8 @@
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@tailwindcss/vite": "^4.3.1",
-    "@urbicon-ui/i18n": "6.34.0",
-    "@urbicon-ui/shared-types": "6.34.0",
+    "@urbicon-ui/i18n": "6.36.0",
+    "@urbicon-ui/shared-types": "6.36.0",
     "prettier": "^3.8.4",
     "prettier-plugin-svelte": "^4.1.1",
     "prettier-plugin-tailwindcss": "^0.8.0",