@streamscloud/kit 0.2.42-1778522742378 → 0.9.0

package/dist/core/files/blob-storage-registry.svelte.d.ts

@@ -0,0 +1,28 @@
+import type { BlobUploadStrategy } from './upload-types';
+/**
+ * Global registry for the blob upload strategy. Consumers register exactly one strategy at app
+ * bootstrap; `UploadMediaStore` reads from this registry on `.upload()`. Mirrors the Toastr /
+ * DialogHost pattern — one configured instance, accessible from anywhere.
+ *
+ * A per-instance override on `UploadMediaStore` is still available for tests and exotic
+ * contexts (e.g. mock backends in stories).
+ *
+ * @example
+ * ```ts
+ * // app bootstrap:
+ * BlobStorage.register(async ({ count, kind }) => {
+ *   const type = kindToGraphqlType(kind);
+ *   const r = await graphql.mutation(CreateBlobUploads, { type, count });
+ *   return r.data.createBlobUploads;
+ * });
+ * ```
+ */
+declare class BlobStorageRegistry {
+    private _strategy;
+    get strategy(): BlobUploadStrategy;
+    get isRegistered(): boolean;
+    register(strategy: BlobUploadStrategy): void;
+    unregister(): void;
+}
+export declare const BlobStorage: BlobStorageRegistry;
+export {};

package/dist/core/files/blob-storage-registry.svelte.js

@@ -0,0 +1,37 @@
+/**
+ * Global registry for the blob upload strategy. Consumers register exactly one strategy at app
+ * bootstrap; `UploadMediaStore` reads from this registry on `.upload()`. Mirrors the Toastr /
+ * DialogHost pattern — one configured instance, accessible from anywhere.
+ *
+ * A per-instance override on `UploadMediaStore` is still available for tests and exotic
+ * contexts (e.g. mock backends in stories).
+ *
+ * @example
+ * ```ts
+ * // app bootstrap:
+ * BlobStorage.register(async ({ count, kind }) => {
+ *   const type = kindToGraphqlType(kind);
+ *   const r = await graphql.mutation(CreateBlobUploads, { type, count });
+ *   return r.data.createBlobUploads;
+ * });
+ * ```
+ */
+class BlobStorageRegistry {
+    _strategy = $state.raw(null);
+    get strategy() {
+        if (!this._strategy) {
+            throw new Error('BlobStorage: no strategy registered. Call BlobStorage.register(...) at app bootstrap.');
+        }
+        return this._strategy;
+    }
+    get isRegistered() {
+        return this._strategy !== null;
+    }
+    register(strategy) {
+        this._strategy = strategy;
+    }
+    unregister() {
+        this._strategy = null;
+    }
+}
+export const BlobStorage = new BlobStorageRegistry();

package/dist/core/files/file-validation-rules.d.ts

@@ -0,0 +1,30 @@
+import type { FileValidationRule } from './file-validation-types';
+/**
+ * Built-in rule factories. Each takes a constraint plus the consumer-supplied localized message
+ * — kit never ships English error strings. Returned rule is a callable function; the `Mime`
+ * factory additionally attaches `.accept` so containing UI cmps (`FileUploader`,
+ * `OpenFileButton`) can auto-derive the native picker filter / drag-over hint.
+ *
+ * @example
+ * ```ts
+ * const rules = [
+ *   FileRules.Mime('image/*', 'Please pick an image.'),
+ *   FileRules.MaxSize(5 * 1024 * 1024, 'Image must be under 5 MB.')
+ * ];
+ * const results = await FileValidator.validateMany(files, rules);
+ * ```
+ */
+export declare const FileRules: {
+    MaxSize: (bytes: number, message: string) => FileValidationRule;
+    Mime: (accept: string, message: string) => FileValidationRule;
+    ImageDimensions: (max: {
+        width: number;
+        height: number;
+    }, message: string) => FileValidationRule;
+    ImageMinDimensions: (min: {
+        width: number;
+        height: number;
+    }, message: string) => FileValidationRule;
+    AudioDuration: (maxSeconds: number, message: string) => FileValidationRule;
+    VideoDuration: (maxSeconds: number, message: string) => FileValidationRule;
+};

package/dist/core/files/file-validation-rules.js

@@ -0,0 +1,95 @@
+/**
+ * Permissive `accept`-style matcher. Tokens may be MIMEs (`image/*`, `application/pdf`) or
+ * extensions (`.pdf`). Empty accept = match anything. Unlike `matchesAcceptedFileTypes` from
+ * `./file-types`, this does NOT cross-check against an internal whitelist — only the
+ * consumer's accept string drives the decision.
+ */
+const matchesAccept = (file, accept) => {
+    if (!accept) {
+        return true;
+    }
+    const tokens = accept
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return true;
+    }
+    const fileType = (file.type || '').toLowerCase();
+    const fileName = file.name.toLowerCase();
+    return tokens.some((t) => {
+        if (t.startsWith('.')) {
+            return fileName.endsWith(t);
+        }
+        if (t.endsWith('/*')) {
+            return fileType.startsWith(t.slice(0, -1));
+        }
+        return fileType === t;
+    });
+};
+const readImageDimensions = (file) => new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(file);
+    const img = new Image();
+    img.onload = () => {
+        URL.revokeObjectURL(url);
+        resolve({ width: img.naturalWidth, height: img.naturalHeight });
+    };
+    img.onerror = () => {
+        URL.revokeObjectURL(url);
+        reject(new Error('Failed to read image dimensions'));
+    };
+    img.src = url;
+});
+const readMediaDuration = (file, kind) => new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(file);
+    const el = kind === 'video' ? document.createElement('video') : document.createElement('audio');
+    el.preload = 'metadata';
+    el.onloadedmetadata = () => {
+        URL.revokeObjectURL(url);
+        resolve(el.duration);
+    };
+    el.onerror = () => {
+        URL.revokeObjectURL(url);
+        reject(new Error(`Failed to read ${kind} duration`));
+    };
+    el.src = url;
+});
+/**
+ * Built-in rule factories. Each takes a constraint plus the consumer-supplied localized message
+ * — kit never ships English error strings. Returned rule is a callable function; the `Mime`
+ * factory additionally attaches `.accept` so containing UI cmps (`FileUploader`,
+ * `OpenFileButton`) can auto-derive the native picker filter / drag-over hint.
+ *
+ * @example
+ * ```ts
+ * const rules = [
+ *   FileRules.Mime('image/*', 'Please pick an image.'),
+ *   FileRules.MaxSize(5 * 1024 * 1024, 'Image must be under 5 MB.')
+ * ];
+ * const results = await FileValidator.validateMany(files, rules);
+ * ```
+ */
+export const FileRules = {
+    MaxSize: (bytes, message) => (file) => file.size > bytes ? message : null,
+    Mime: (accept, message) => {
+        const rule = (file) => (matchesAccept(file, accept) ? null : message);
+        rule.accept = accept;
+        return rule;
+    },
+    ImageDimensions: (max, message) => async (file) => {
+        const { width, height } = await readImageDimensions(file);
+        return width > max.width || height > max.height ? message : null;
+    },
+    ImageMinDimensions: (min, message) => async (file) => {
+        const { width, height } = await readImageDimensions(file);
+        return width < min.width || height < min.height ? message : null;
+    },
+    AudioDuration: (maxSeconds, message) => async (file) => {
+        const duration = await readMediaDuration(file, 'audio');
+        return duration > maxSeconds ? message : null;
+    },
+    VideoDuration: (maxSeconds, message) => async (file) => {
+        const duration = await readMediaDuration(file, 'video');
+        return duration > maxSeconds ? message : null;
+    }
+};

package/dist/core/files/file-validation-types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Single async validation rule. Returns `null` (or empty array) when the file is valid,
+ * a string (or array of strings) when invalid. The consumer supplies the localized message
+ * when constructing the rule — kit ships only rule factories, never English defaults.
+ *
+ * Optional `accept` property: when set (only the `FileRules.Mime` factory does this), the
+ * containing UI cmps (`FileUploader`, `OpenFileButton`) auto-derive the native picker filter
+ * + drag-over visual hint from it. Lets the consumer write the MIME pattern exactly once.
+ */
+export type FileValidationRule = ((file: File) => string | string[] | null | Promise<string | string[] | null>) & {
+    accept?: string;
+};
+/** Aggregate validation result for a single file across one or more rules. */
+export type FileValidationResult = {
+    file: File;
+    isValid: boolean;
+    errors: string[];
+};

package/dist/core/files/file-validator.d.ts

@@ -0,0 +1,5 @@
+import type { FileValidationResult, FileValidationRule } from './file-validation-types';
+export declare class FileValidator {
+    static validate(file: File, rules: FileValidationRule[]): Promise<FileValidationResult>;
+    static validateMany(files: File[], rules: FileValidationRule[]): Promise<FileValidationResult[]>;
+}

package/dist/core/files/file-validator.js

@@ -0,0 +1,17 @@
+const toArray = (v) => (v === null ? [] : Array.isArray(v) ? v : [v]);
+export class FileValidator {
+    static async validate(file, rules) {
+        const errors = [];
+        for (const rule of rules) {
+            const result = await rule(file);
+            const msgs = toArray(result);
+            if (msgs.length > 0) {
+                errors.push(...msgs);
+            }
+        }
+        return { file, isValid: errors.length === 0, errors };
+    }
+    static async validateMany(files, rules) {
+        return Promise.all(files.map((f) => FileValidator.validate(f, rules)));
+    }
+}

package/dist/core/files/index.d.ts

@@ -1,9 +1,17 @@
 export type { BlobWithName, FileWithBlobUrl, FileWithUploadUrl } from './types';
+export type { FileValidationResult, FileValidationRule } from './file-validation-types';
+export type { BlobKind, BlobKinds, BlobUpload, BlobUploadStrategy, UploadingFile, UploadingFileStatus } from './upload-types';
+export type { UploadMediaStoreOptions } from './upload-media-store.svelte';
 export { toBlobWithName, toFileWithUploadUrl } from './types';
 export { uploadBlob } from './blob-storage';
+export { openFile } from './open-file';
 export { FileHelper } from './file-helper';
 export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
 export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
 export { resizeBlob, resizeImage } from './image-resizer';
 export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
 export { FilesProvider } from './files-provider';
+export { FileValidator } from './file-validator';
+export { FileRules } from './file-validation-rules';
+export { BlobStorage } from './blob-storage-registry.svelte';
+export { UploadMediaStore } from './upload-media-store.svelte';

package/dist/core/files/index.js

@@ -1,9 +1,14 @@
 // Utilities
 export { toBlobWithName, toFileWithUploadUrl } from './types';
 export { uploadBlob } from './blob-storage';
+export { openFile } from './open-file';
 export { FileHelper } from './file-helper';
 export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
 export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
 export { resizeBlob, resizeImage } from './image-resizer';
 export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
 export { FilesProvider } from './files-provider';
+export { FileValidator } from './file-validator';
+export { FileRules } from './file-validation-rules';
+export { BlobStorage } from './blob-storage-registry.svelte';
+export { UploadMediaStore } from './upload-media-store.svelte';

package/dist/core/files/open-file.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Programmatically open a native file picker. Creates a hidden `<input type="file">`, awaits
+ * the `change` event, and resolves with the selected files (or empty array on cancel).
+ *
+ * @example
+ * ```ts
+ * const files = await openFile({ multiple: true, accept: 'image/*' });
+ * ```
+ */
+export declare const openFile: (opts?: {
+    multiple?: boolean;
+    accept?: string;
+    capture?: "user" | "environment";
+}) => Promise<File[]>;

package/dist/core/files/open-file.js

@@ -0,0 +1,38 @@
+/**
+ * Programmatically open a native file picker. Creates a hidden `<input type="file">`, awaits
+ * the `change` event, and resolves with the selected files (or empty array on cancel).
+ *
+ * @example
+ * ```ts
+ * const files = await openFile({ multiple: true, accept: 'image/*' });
+ * ```
+ */
+export const openFile = (opts) => new Promise((resolve) => {
+    const input = document.createElement('input');
+    input.type = 'file';
+    if (opts?.multiple) {
+        input.multiple = true;
+    }
+    if (opts?.accept) {
+        input.accept = opts.accept;
+    }
+    if (opts?.capture) {
+        input.capture = opts.capture;
+    }
+    input.style.display = 'none';
+    // Fire-and-forget — both `change` (file picked) and `cancel` (dialog dismissed) clean up.
+    const cleanup = () => {
+        input.remove();
+    };
+    input.onchange = () => {
+        const files = Array.from(input.files ?? []);
+        cleanup();
+        resolve(files);
+    };
+    input.oncancel = () => {
+        cleanup();
+        resolve([]);
+    };
+    document.body.appendChild(input);
+    input.click();
+});

package/dist/core/files/upload-media-store.svelte.d.ts

@@ -0,0 +1,74 @@
+import type { BlobKind, BlobUploadStrategy, UploadingFile } from './upload-types';
+export type UploadMediaStoreOptions = {
+    /** Discriminator forwarded to the registered `BlobUploadStrategy`. */
+    kind?: BlobKind;
+    /**
+     * Override the globally registered `BlobStorage` strategy for this store instance.
+     * Useful for tests / stories.
+     */
+    strategy?: BlobUploadStrategy;
+    /**
+     * Auto-resize images before upload. Pass `false` to disable; pass an object to override the
+     * defaults. `max1` / `max2` are not tied to width / height — the longer side is matched to
+     * the larger limit. @default `{ max1: 1600, max2: 1000 }`
+     */
+    resize?: {
+        max1: number;
+        max2: number;
+    } | false;
+    /** Parallel upload limit. @default 20 */
+    concurrency?: number;
+    on?: {
+        /** Fires per file once its presigned URL is allocated and the blob is uploaded. */
+        blobId?: (file: UploadingFile, blobId: string) => void;
+        /** Fires per file when the upload errors out. */
+        error?: (file: UploadingFile, error: unknown) => void;
+        /** Fires once after all queued files have either succeeded or errored. */
+        done?: () => void;
+    };
+};
+/**
+ * Queue-and-upload coordinator. Pure logic — no UI. Pair with `FileRow` / `FileUploadProgress`
+ * for visual progress, both of which consume the `files: UploadingFile[]` array reactively.
+ *
+ * Lifecycle:
+ * 1. `add(file)` — push raw `File` into the queue (`status: 'queued'`).
+ * 2. `upload()` — fetch presigned URLs from the strategy, then PUT each blob in parallel.
+ *    Per-file status flows `queued → uploading → success | error`; `progress` updates as
+ *    bytes are sent.
+ * 3. Consumer wires `on.blobId` to capture each blob ID for form state, or reads `files[i].blobId`.
+ *
+ * @example
+ * ```ts
+ * const store = new UploadMediaStore({
+ *   kind: 'avatar',
+ *   on: { blobId: (f, id) => { avatarBlobId = id; } }
+ * });
+ * store.add(rawFile);
+ * await store.upload();
+ * ```
+ */
+export declare class UploadMediaStore {
+    private _files;
+    private opts;
+    constructor(opts?: UploadMediaStoreOptions);
+    /** Reactive read of the queue. */
+    get files(): UploadingFile[];
+    /** Append a raw `File`, returns its `UploadingFile` wrapper (with a stable `id`). */
+    add(file: File): UploadingFile;
+    /** Append multiple raw files at once. */
+    addMany(files: File[]): UploadingFile[];
+    /** Remove a file from the queue by its `UploadingFile.id`. Does NOT cancel an in-flight upload. */
+    remove(id: string): void;
+    /** Clear all queued / completed files. Does NOT cancel any in-flight uploads. */
+    clear(): void;
+    /**
+     * Run the upload pipeline for every file currently in `'queued'` status. Files already
+     * `uploading` / `success` / `error` are skipped. Resolves once every targeted file has a
+     * terminal status.
+     */
+    upload(): Promise<void>;
+    private maybeResize;
+    private patch;
+    private byId;
+}

package/dist/core/files/upload-media-store.svelte.js

@@ -0,0 +1,118 @@
+import { uploadBlob } from './blob-storage';
+import { BlobStorage } from './blob-storage-registry.svelte';
+import { resizeBlob } from './image-resizer';
+import { nanoid } from 'nanoid';
+import { default as pLimit } from 'p-limit';
+const DEFAULT_RESIZE_LIMITS = { max1: 1600, max2: 1000 };
+const DEFAULT_CONCURRENCY = 20;
+/**
+ * Queue-and-upload coordinator. Pure logic — no UI. Pair with `FileRow` / `FileUploadProgress`
+ * for visual progress, both of which consume the `files: UploadingFile[]` array reactively.
+ *
+ * Lifecycle:
+ * 1. `add(file)` — push raw `File` into the queue (`status: 'queued'`).
+ * 2. `upload()` — fetch presigned URLs from the strategy, then PUT each blob in parallel.
+ *    Per-file status flows `queued → uploading → success | error`; `progress` updates as
+ *    bytes are sent.
+ * 3. Consumer wires `on.blobId` to capture each blob ID for form state, or reads `files[i].blobId`.
+ *
+ * @example
+ * ```ts
+ * const store = new UploadMediaStore({
+ *   kind: 'avatar',
+ *   on: { blobId: (f, id) => { avatarBlobId = id; } }
+ * });
+ * store.add(rawFile);
+ * await store.upload();
+ * ```
+ */
+export class UploadMediaStore {
+    _files = $state.raw([]);
+    opts;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    /** Reactive read of the queue. */
+    get files() {
+        return this._files;
+    }
+    /** Append a raw `File`, returns its `UploadingFile` wrapper (with a stable `id`). */
+    add(file) {
+        const uploadingFile = { id: nanoid(), file, progress: 0, status: 'queued' };
+        this._files = [...this._files, uploadingFile];
+        return uploadingFile;
+    }
+    /** Append multiple raw files at once. */
+    addMany(files) {
+        const wrappers = files.map((file) => ({ id: nanoid(), file, progress: 0, status: 'queued' }));
+        this._files = [...this._files, ...wrappers];
+        return wrappers;
+    }
+    /** Remove a file from the queue by its `UploadingFile.id`. Does NOT cancel an in-flight upload. */
+    remove(id) {
+        this._files = this._files.filter((f) => f.id !== id);
+    }
+    /** Clear all queued / completed files. Does NOT cancel any in-flight uploads. */
+    clear() {
+        this._files = [];
+    }
+    /**
+     * Run the upload pipeline for every file currently in `'queued'` status. Files already
+     * `uploading` / `success` / `error` are skipped. Resolves once every targeted file has a
+     * terminal status.
+     */
+    async upload() {
+        const queued = this._files.filter((f) => f.status === 'queued');
+        if (queued.length === 0) {
+            return;
+        }
+        const strategy = this.opts.strategy ?? BlobStorage.strategy;
+        const presigned = await strategy({ count: queued.length, kind: this.opts.kind });
+        if (presigned.length < queued.length) {
+            throw new Error(`BlobUploadStrategy returned ${presigned.length} slots for ${queued.length} files`);
+        }
+        const limit = pLimit(this.opts.concurrency ?? DEFAULT_CONCURRENCY);
+        const resizeOpt = this.opts.resize;
+        await Promise.all(queued.map((entry, i) => limit(async () => {
+            this.patch(entry.id, { status: 'uploading', progress: 0 });
+            try {
+                const blob = resizeOpt === false ? entry.file : await this.maybeResize(entry.file, resizeOpt ?? DEFAULT_RESIZE_LIMITS);
+                const slot = presigned[i];
+                await uploadBlob(slot.url, blob, (loaded, total) => {
+                    this.patch(entry.id, { progress: total > 0 ? loaded / total : 0 });
+                });
+                this.patch(entry.id, { status: 'success', progress: 1, blobId: slot.id });
+                this.opts.on?.blobId?.(this.byId(entry.id), slot.id);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Upload failed';
+                this.patch(entry.id, { status: 'error', error: message });
+                this.opts.on?.error?.(this.byId(entry.id), error);
+            }
+        })));
+        this.opts.on?.done?.();
+    }
+    async maybeResize(file, limits) {
+        // Only resize images — leave other media alone.
+        if (!file.type.startsWith('image/') || file.type === 'image/gif') {
+            return file;
+        }
+        try {
+            return await resizeBlob(file, limits);
+        }
+        catch {
+            // Resize is best-effort: fall back to the original on failure (e.g. corrupt file).
+            return file;
+        }
+    }
+    patch(id, partial) {
+        this._files = this._files.map((f) => (f.id === id ? { ...f, ...partial } : f));
+    }
+    byId(id) {
+        const found = this._files.find((f) => f.id === id);
+        if (!found) {
+            throw new Error(`UploadMediaStore: file ${id} not found`);
+        }
+        return found;
+    }
+}

package/dist/core/files/upload-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Domain tags for blob uploads. Empty by default — the consumer augments via TypeScript
+ * declaration merging at app bootstrap to get type-safe `kind` strings everywhere.
+ *
+ * @example
+ * ```ts
+ * // app-side (e.g. src/app.d.ts)
+ * declare module '@streamscloud/kit/core/files' {
+ *   interface BlobKinds {
+ *     avatar: never;
+ *     asset: never;
+ *     organization: never;
+ *   }
+ * }
+ *
+ * // Now type-checked at all use sites:
+ * new UploadMediaStore({ kind: 'avatar' });    // ✓
+ * new UploadMediaStore({ kind: 'typo' });      // ✗ TS error
+ * ```
+ *
+ * Without augmentation, `BlobKind` falls back to `string` so the API stays usable.
+ */
+export interface BlobKinds {
+}
+export type BlobKind = keyof BlobKinds extends never ? string : keyof BlobKinds;
+/** A single presigned blob upload slot returned by a `BlobUploadStrategy`. */
+export type BlobUpload = {
+    id: string;
+    url: string;
+};
+/**
+ * Async producer of presigned blob upload slots. The consumer registers ONE strategy at app
+ * bootstrap via `BlobStorage.register(...)`; it is called by `UploadMediaStore.upload()` with
+ * the queued file count and an optional `kind` discriminator that the consumer maps to its
+ * own backend (e.g. a GraphQL enum).
+ */
+export type BlobUploadStrategy = (request: {
+    count: number;
+    kind?: BlobKind;
+}) => Promise<BlobUpload[]>;
+/** Lifecycle status of a single file flowing through `UploadMediaStore`. */
+export type UploadingFileStatus = 'queued' | 'uploading' | 'success' | 'error';
+/**
+ * Canonical shape passed to `FileRow` / `FileUploadProgress` and emitted by `UploadMediaStore`.
+ * Fields update reactively as the upload progresses.
+ */
+export type UploadingFile = {
+    id: string;
+    file: File;
+    /** 0..1 — fraction uploaded. 1 on success. */
+    progress: number;
+    status: UploadingFileStatus;
+    /** Set when `status === 'success'`. */
+    blobId?: string;
+    /** Set when `status === 'error'`. */
+    error?: string;
+};

package/dist/core/transitions/durations.d.ts

@@ -0,0 +1,5 @@
+export declare const transitionDuration: {
+    readonly fast: 80;
+    readonly base: 160;
+    readonly slow: 240;
+};

package/dist/core/transitions/durations.js

@@ -0,0 +1,6 @@
+// JS mirror of the --sc-kit--duration--* CSS tokens (svelte/transition needs a numeric literal, not a CSS var). Keep values in sync with styles/_semantic.scss.
+export const transitionDuration = {
+    fast: 80,
+    base: 160,
+    slow: 240
+};

package/dist/core/transitions/index.d.ts

@@ -1 +1,2 @@
+export { transitionDuration } from './durations';
 export { slideHorizontally } from './slide-horizontally';

package/dist/core/transitions/index.js

@@ -1 +1,2 @@
+export { transitionDuration } from './durations';
 export { slideHorizontally } from './slide-horizontally';

package/dist/core/transitions/slide-horizontally.js

@@ -1,5 +1,6 @@
+import { transitionDuration } from './durations';
 import { sineInOut } from 'svelte/easing';
-export const slideHorizontally = (node, { delay = 0, duration = 250, easing = sineInOut } = {}) => {
+export const slideHorizontally = (node, { delay = 0, duration = transitionDuration.base, easing = sineInOut } = {}) => {
     const style = getComputedStyle(node);
     const isHtmlElement = (n) => n.nodeType === Node.ELEMENT_NODE;
     const children = Array.from(node.children).filter(isHtmlElement);

package/dist/core/utils/href-validator.d.ts

@@ -1,13 +1,4 @@
-export declare enum ValidationError {
-    NotString = 0,
-    Empty = 1,
-    ControlChars = 2,
-    DisallowedScheme = 3,
-    MissingHost = 4,
-    EmbeddedCredentials = 5,
-    Relative = 6,
-    BareRelative = 7
-}
+export type ValidationError = 'NotString' | 'Empty' | 'ControlChars' | 'DisallowedScheme' | 'MissingHost' | 'EmbeddedCredentials' | 'Relative' | 'BareRelative';
 type DetailedResult = {
     valid: true;
 } | {