@streamscloud/kit 0.13.0 → 0.14.0

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

@@ -1,6 +1,6 @@
 export type { BlobWithName, FileWithBlobUrl, FileWithUploadUrl } from './types';
 export type { AspectRatioBound, FileValidationResult, FileValidationRule, FileValidationRuleSets, VideoOrientationValue } from './file-validation-types';
-export type { BlobKind, BlobKinds, BlobUpload, BlobUploadStrategy, UploadingFile, UploadingFileStatus } from './upload-types';
+export type { 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';
@@ -14,5 +14,4 @@ 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

@@ -11,5 +11,4 @@ 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/upload-media-store.svelte.d.ts

@@ -1,12 +1,11 @@
-import type { BlobKind, BlobUploadStrategy, UploadingFile } from './upload-types';
+import type { BlobUploadStrategy, UploadingFile } from './upload-types';
+type SuccessfulUpload = Extract<UploadingFile, {
+    status: 'success';
+}>;
+type FailedUpload = Extract<UploadingFile, {
+    status: 'error';
+}>;
 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
@@ -20,9 +19,9 @@ export type UploadMediaStoreOptions = {
     concurrency?: number;
     on?: {
         /** Fires per file once its presigned URL is allocated and the blob is uploaded. */
-        blobId?: (file: UploadingFile, blobId: string) => void;
+        blobId?: (file: SuccessfulUpload, blobId: string) => void;
         /** Fires per file when the upload errors out. */
-        error?: (file: UploadingFile, error: unknown) => void;
+        error?: (file: FailedUpload, error: unknown) => void;
         /** Fires once after all queued files have either succeeded or errored. */
         done?: () => void;
     };
@@ -40,8 +39,7 @@ export type UploadMediaStoreOptions = {
  *
  * @example
  * ```ts
- * const store = new UploadMediaStore({
- *   kind: 'avatar',
+ * const store = new UploadMediaStore(uploadStrategy, {
  *   on: { blobId: (f, id) => { avatarBlobId = id; } }
  * });
  * store.add(rawFile);
@@ -50,8 +48,9 @@ export type UploadMediaStoreOptions = {
  */
 export declare class UploadMediaStore {
     private _files;
+    private _strategy;
     private opts;
-    constructor(opts?: UploadMediaStoreOptions);
+    constructor(strategy: BlobUploadStrategy, opts?: UploadMediaStoreOptions);
     /** Reactive read of the queue. */
     get files(): UploadingFile[];
     /** Append a raw `File`, returns its `UploadingFile` wrapper (with a stable `id`). */
@@ -69,6 +68,8 @@ export declare class UploadMediaStore {
      */
     upload(): Promise<void>;
     private maybeResize;
-    private patch;
-    private byId;
+    private fail;
+    private failAll;
+    private transition;
 }
+export {};

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

@@ -1,5 +1,4 @@
 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';
@@ -18,8 +17,7 @@ const DEFAULT_CONCURRENCY = 20;
  *
  * @example
  * ```ts
- * const store = new UploadMediaStore({
- *   kind: 'avatar',
+ * const store = new UploadMediaStore(uploadStrategy, {
  *   on: { blobId: (f, id) => { avatarBlobId = id; } }
  * });
  * store.add(rawFile);
@@ -28,8 +26,10 @@ const DEFAULT_CONCURRENCY = 20;
  */
 export class UploadMediaStore {
     _files = $state.raw([]);
+    _strategy;
     opts;
-    constructor(opts = {}) {
+    constructor(strategy, opts = {}) {
+        this._strategy = strategy;
         this.opts = opts;
     }
     /** Reactive read of the queue. */
@@ -66,28 +66,35 @@ export class UploadMediaStore {
         if (queued.length === 0) {
             return;
         }
-        const strategy = this.opts.strategy ?? BlobStorage.strategy;
-        const presigned = await strategy({ count: queued.length, kind: this.opts.kind });
+        let presigned;
+        try {
+            presigned = await this._strategy(queued.length);
+        }
+        catch (error) {
+            this.failAll(queued, error);
+            return;
+        }
         if (presigned.length < queued.length) {
-            throw new Error(`BlobUploadStrategy returned ${presigned.length} slots for ${queued.length} files`);
+            this.failAll(queued, new Error(`BlobUploadStrategy returned ${presigned.length} slots for ${queued.length} files`));
+            return;
         }
         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 });
+            this.transition(entry.id, (f) => ({ id: f.id, file: f.file, progress: 0, status: 'uploading' }));
             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 });
+                await uploadBlob(slot.uploadUrl, blob, (loaded, total) => {
+                    this.transition(entry.id, (f) => (f.status === 'uploading' ? { ...f, progress: total > 0 ? loaded / total : 0 } : f));
                 });
-                this.patch(entry.id, { status: 'success', progress: 1, blobId: slot.id });
-                this.opts.on?.blobId?.(this.byId(entry.id), slot.id);
+                const done = this.transition(entry.id, (f) => ({ id: f.id, file: f.file, progress: 1, status: 'success', blobId: slot.id, readUrl: slot.readUrl }));
+                if (done?.status === 'success') {
+                    this.opts.on?.blobId?.(done, 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.fail(entry.id, error);
             }
         })));
         this.opts.on?.done?.();
@@ -105,14 +112,28 @@ export class UploadMediaStore {
             return file;
         }
     }
-    patch(id, partial) {
-        this._files = this._files.map((f) => (f.id === id ? { ...f, ...partial } : f));
+    fail(id, error) {
+        const message = error instanceof Error ? error.message : 'Upload failed';
+        const failed = this.transition(id, (f) => ({ id: f.id, file: f.file, progress: f.progress, status: 'error', error: message }));
+        if (failed?.status === 'error') {
+            this.opts.on?.error?.(failed, error);
+        }
     }
-    byId(id) {
-        const found = this._files.find((f) => f.id === id);
-        if (!found) {
-            throw new Error(`UploadMediaStore: file ${id} not found`);
+    failAll(files, error) {
+        for (const entry of files) {
+            this.fail(entry.id, error);
         }
-        return found;
+        this.opts.on?.done?.();
+    }
+    transition(id, next) {
+        let updated;
+        this._files = this._files.map((f) => {
+            if (f.id !== id) {
+                return f;
+            }
+            updated = next(f);
+            return updated;
+        });
+        return updated;
     }
 }

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

@@ -1,57 +1,42 @@
-/**
- * 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;
+    /** Presigned URL the blob is PUT to. */
+    uploadUrl: string;
+    /** URL the uploaded blob can be read back from. */
+    readUrl: 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).
+ * Async producer of presigned blob upload slots, passed to the `UploadMediaStore` constructor.
+ * Called by `UploadMediaStore.upload()` with the queued file count; the strategy decides where
+ * and how to allocate the slots (e.g. a GraphQL mutation against the consumer's backend) and
+ * returns one `BlobUpload` per requested file.
  */
-export type BlobUploadStrategy = (request: {
-    count: number;
-    kind?: BlobKind;
-}) => Promise<BlobUpload[]>;
+export type BlobUploadStrategy = (count: number) => 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 = {
+type UploadingFileBase = {
     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;
 };
+/**
+ * Canonical shape passed to `FileRow` / `FileUploadProgress` and emitted by `UploadMediaStore`,
+ * discriminated by `status`. The `success` variant carries the resolved `blobId` / `readUrl`
+ * and the `error` variant carries the message, so consumers narrow on `status` instead of
+ * null-checking optional fields. Fields update reactively as the upload progresses.
+ */
+export type UploadingFile = (UploadingFileBase & {
+    status: 'queued';
+}) | (UploadingFileBase & {
+    status: 'uploading';
+}) | (UploadingFileBase & {
+    status: 'success';
+    blobId: string;
+    readUrl: string;
+}) | (UploadingFileBase & {
+    status: 'error';
+    error: string;
+});
+export {};

package/dist/ui/file-uploader/cmp.file-row.svelte

@@ -20,8 +20,8 @@ const sizeText = $derived(StringHelper.toFileSizeString(file.file.size));
     <div class="file-row__name">{file.file.name}</div>
     {#if isUploading}
       <div class="file-row__sub">{percent}% · {localization.uploadingHint}</div>
-    {:else if isError}
-      <div class="file-row__sub file-row__sub--error">{file.error ?? ''}</div>
+    {:else if file.status === 'error'}
+      <div class="file-row__sub file-row__sub--error">{file.error}</div>
     {:else}
       <div class="file-row__sub">{sizeText}</div>
     {/if}

package/dist/ui/file-uploader/cmp.file-upload-progress.svelte

@@ -22,8 +22,8 @@ const isError = $derived(file.status === 'error');
     <div class="file-upload-progress__bar" aria-hidden="true">
       <span style:width="{percent}%"></span>
     </div>
-    {#if isError}
-      <div class="file-upload-progress__sub file-upload-progress__sub--error">{file.error ?? ''}</div>
+    {#if file.status === 'error'}
+      <div class="file-upload-progress__sub file-upload-progress__sub--error">{file.error}</div>
     {:else}
       <div class="file-upload-progress__sub">{sizeText}</div>
     {/if}

package/dist/ui/file-uploader/to-uploading-file.d.ts

@@ -2,6 +2,8 @@ import type { UploadingFile, UploadingFileStatus } from '../../core/files';
 /**
  * Wrap a raw `File` into an `UploadingFile` for ad-hoc rendering with `FileRow` /
  * `FileUploadProgress` (e.g. static read-only file lists, mocks in stories). Defaults to
- * `status: 'success'` and `progress: 1` — i.e. "already complete, just show me".
+ * `status: 'success'` and `progress: 1` — i.e. "already complete, just show me". The display
+ * components read only `file` / `progress` / `status` / `error`, so the `success` variant's
+ * `blobId` / `readUrl` are empty placeholders here — this shim has no backing blob.
  */
 export declare const toUploadingFile: (file: File, status?: UploadingFileStatus) => UploadingFile;

package/dist/ui/file-uploader/to-uploading-file.js

@@ -1,12 +1,24 @@
+import { Utils } from '../../core/utils';
 import { nanoid } from 'nanoid';
 /**
  * Wrap a raw `File` into an `UploadingFile` for ad-hoc rendering with `FileRow` /
  * `FileUploadProgress` (e.g. static read-only file lists, mocks in stories). Defaults to
- * `status: 'success'` and `progress: 1` — i.e. "already complete, just show me".
+ * `status: 'success'` and `progress: 1` — i.e. "already complete, just show me". The display
+ * components read only `file` / `progress` / `status` / `error`, so the `success` variant's
+ * `blobId` / `readUrl` are empty placeholders here — this shim has no backing blob.
  */
-export const toUploadingFile = (file, status = 'success') => ({
-    id: nanoid(),
-    file,
-    progress: status === 'success' ? 1 : 0,
-    status
-});
+export const toUploadingFile = (file, status = 'success') => {
+    const base = { id: nanoid(), file };
+    switch (status) {
+        case 'queued':
+            return { ...base, progress: 0, status };
+        case 'uploading':
+            return { ...base, progress: 0, status };
+        case 'success':
+            return { ...base, progress: 1, status, blobId: '', readUrl: '' };
+        case 'error':
+            return { ...base, progress: 0, status, error: '' };
+        default:
+            return Utils.assertUnreachable(status);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",

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

@@ -1,28 +0,0 @@
-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

@@ -1,37 +0,0 @@
-/**
- * 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();