@streamscloud/kit 0.0.1-1770364570820

package/dist/core/continuation-token.d.ts

@@ -0,0 +1,10 @@
+export declare class ContinuationToken {
+    canLoadMore: boolean;
+    value: string | null;
+    private constructor();
+    static init(): ContinuationToken;
+    static fromPayload(value: string | null): ContinuationToken;
+    static preventLoading(): ContinuationToken;
+    toString(): string | null;
+    toJSON(): string | null;
+}

package/dist/core/continuation-token.js

@@ -0,0 +1,32 @@
+export class ContinuationToken {
+    canLoadMore;
+    value;
+    constructor(canLoadMore, value) {
+        this.canLoadMore = canLoadMore;
+        this.value = value;
+    }
+    static init() {
+        // initial state, no data is loaded so far
+        return new ContinuationToken(true, null);
+    }
+    static fromPayload(value) {
+        if (value?.length && value.length > 0 && value.length < 5000) {
+            // initialized with server response that there is more data, and value is valid
+            return new ContinuationToken(true, value);
+        }
+        else {
+            // initialized with server response that there is no more data or value is invalid
+            return new ContinuationToken(false, null);
+        }
+    }
+    static preventLoading() {
+        // additional initilizer, to block further loading
+        return new ContinuationToken(false, null);
+    }
+    toString() {
+        return this.value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

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

@@ -0,0 +1 @@
+export { Css } from './style-functions';

package/dist/core/css/index.js

@@ -0,0 +1 @@
+export { Css } from './style-functions';

package/dist/core/css/style-functions.d.ts

@@ -0,0 +1,5 @@
+export declare class Css {
+    static rem: (value: number) => string;
+    static remValue: (value: number) => number;
+    static em: (value: number, base?: number) => string;
+}

package/dist/core/css/style-functions.js

@@ -0,0 +1,12 @@
+const baseValue = 16;
+export class Css {
+    static rem = (value) => {
+        return `${Css.remValue(value)}rem`;
+    };
+    static remValue = (value) => {
+        return value / baseValue;
+    };
+    static em = (value, base = baseValue) => {
+        return `${value / base}em`;
+    };
+}

package/dist/core/cursor-result.d.ts

@@ -0,0 +1,9 @@
+import type { ContinuationToken } from './continuation-token';
+export type CursorResult<T> = {
+    items: T[];
+    continuationToken: ContinuationToken;
+};
+export type CursorPayload<T> = {
+    items: T[];
+    continuationToken: string | null;
+};

package/dist/core/cursor-result.js

@@ -0,0 +1 @@
+export {};

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.d.ts

@@ -0,0 +1,19 @@
+import { ContinuationToken, type CursorResult } from '..';
+import type { IDataLoader } from './data-loader';
+export declare class CursorDataLoaderWithSearch<T> implements IDataLoader<T> {
+    items: T[];
+    private continuationToken;
+    private _searchString;
+    private loadPage;
+    private deferred;
+    private searchStringMinLength;
+    constructor(init: {
+        loadPage: (continuationToken: ContinuationToken, searchString: string) => Promise<CursorResult<T> | null>;
+        searchStringMinLength?: number;
+    });
+    get searchString(): string;
+    loadMore: () => Promise<T[]>;
+    reset(): Promise<void>;
+    updateSearchString: (searchString: string | null) => void;
+    private isSearchStringEffective;
+}

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.js

@@ -0,0 +1,57 @@
+import { ContinuationToken, Deferred } from '..';
+import { Utils } from '../utils';
+export class CursorDataLoaderWithSearch {
+    items = $state.raw([]);
+    continuationToken = $state.raw(ContinuationToken.init());
+    _searchString = $state.raw('');
+    loadPage;
+    deferred = null;
+    searchStringMinLength = 1;
+    constructor(init) {
+        this.loadPage = init.loadPage;
+        if (init.searchStringMinLength !== undefined) {
+            this.searchStringMinLength = init.searchStringMinLength;
+        }
+        this.updateSearchString = Utils.debounce(this.updateSearchString, 400);
+    }
+    get searchString() {
+        return this._searchString;
+    }
+    loadMore = async () => {
+        if (this.deferred) {
+            return this.deferred.promise;
+        }
+        if (!this.continuationToken.canLoadMore) {
+            return [];
+        }
+        this.deferred = new Deferred();
+        const search = this.isSearchStringEffective(this._searchString) ? this._searchString : '';
+        let result = await this.loadPage(this.continuationToken, search);
+        if (!result) {
+            result = { items: [], continuationToken: ContinuationToken.preventLoading() };
+        }
+        this.continuationToken = result.continuationToken;
+        this.items = [...this.items, ...result.items];
+        this.deferred.resolve(result.items);
+        this.deferred = null;
+        return result.items;
+    };
+    async reset() {
+        this.items = [];
+        this.continuationToken = ContinuationToken.init();
+        await this.loadMore();
+    }
+    updateSearchString = (searchString) => {
+        const newValue = searchString || '';
+        if (newValue === this._searchString) {
+            return;
+        }
+        const wasEffective = this.isSearchStringEffective(this._searchString);
+        const isEffective = this.isSearchStringEffective(newValue);
+        this._searchString = newValue;
+        if (wasEffective || isEffective) {
+            this.reset();
+        }
+    };
+    isSearchStringEffective = (searchString) => searchString && searchString.length >= this.searchStringMinLength;
+}

package/dist/core/data-loaders/cursor-data-loader.svelte.d.ts

@@ -0,0 +1,13 @@
+import { ContinuationToken, type CursorResult } from '..';
+import type { IDataLoader } from './data-loader';
+export declare class CursorDataLoader<T> implements IDataLoader<T> {
+    items: T[];
+    continuationToken: ContinuationToken;
+    private loadPage;
+    private deferred;
+    constructor(init: {
+        loadPage: (continuationToken: ContinuationToken) => Promise<CursorResult<T> | null>;
+    });
+    loadMore: () => Promise<T[]>;
+    reset(): Promise<void>;
+}

package/dist/core/data-loaders/cursor-data-loader.svelte.js

@@ -0,0 +1,33 @@
+import { ContinuationToken, Deferred } from '..';
+export class CursorDataLoader {
+    items = $state.raw([]);
+    continuationToken = $state.raw(ContinuationToken.init());
+    loadPage;
+    deferred = null;
+    constructor(init) {
+        this.loadPage = init.loadPage;
+    }
+    loadMore = async () => {
+        if (this.deferred) {
+            return this.deferred.promise;
+        }
+        if (!this.continuationToken.canLoadMore) {
+            return [];
+        }
+        this.deferred = new Deferred();
+        let result = await this.loadPage(this.continuationToken);
+        if (!result) {
+            result = { items: [], continuationToken: ContinuationToken.preventLoading() };
+        }
+        this.continuationToken = result.continuationToken;
+        this.items = [...this.items, ...result.items];
+        this.deferred.resolve(result.items);
+        this.deferred = null;
+        return result.items;
+    };
+    async reset() {
+        this.items = [];
+        this.continuationToken = ContinuationToken.init();
+        await this.loadMore();
+    }
+}

package/dist/core/data-loaders/data-loader.d.ts

@@ -0,0 +1,4 @@
+export interface IDataLoader<T> {
+    items: T[];
+    loadMore: () => Promise<T[]>;
+}

package/dist/core/data-loaders/data-loader.js

@@ -0,0 +1 @@
+export {};

package/dist/core/data-loaders/index.d.ts

@@ -0,0 +1,4 @@
+export type { IDataLoader } from './data-loader';
+export { CursorDataLoader } from './cursor-data-loader.svelte';
+export { CursorDataLoaderWithSearch } from './cursor-data-loader-with-search.svelte';
+export { PageDataLoader } from './page-data-loader.svelte';

package/dist/core/data-loaders/index.js

@@ -0,0 +1,4 @@
+// Data loaders
+export { CursorDataLoader } from './cursor-data-loader.svelte';
+export { CursorDataLoaderWithSearch } from './cursor-data-loader-with-search.svelte';
+export { PageDataLoader } from './page-data-loader.svelte';

package/dist/core/data-loaders/page-data-loader.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { IDataLoader } from './data-loader';
+export declare class PageDataLoader<T> implements IDataLoader<T> {
+    private _items;
+    private canLoadMore;
+    private perPage;
+    private loadPage;
+    private pageNumber;
+    constructor(init: {
+        loadPage: (page: number, perPage: number) => Promise<T[]>;
+        perPage?: number;
+    });
+    get items(): T[];
+    loadMore: () => Promise<T[]>;
+    reset: () => Promise<void>;
+}

package/dist/core/data-loaders/page-data-loader.svelte.js

@@ -0,0 +1,37 @@
+export class PageDataLoader {
+    _items = $state.raw([]);
+    canLoadMore = $state(true);
+    perPage = 20;
+    loadPage;
+    pageNumber = 1;
+    constructor(init) {
+        this.loadPage = init.loadPage;
+        if (init.perPage) {
+            this.perPage = init.perPage;
+        }
+    }
+    get items() {
+        return this._items;
+    }
+    loadMore = async () => {
+        if (!this.canLoadMore) {
+            return [];
+        }
+        try {
+            const items = await this.loadPage(this.pageNumber++, this.perPage);
+            this.canLoadMore = items.length === this.perPage;
+            this._items = [...this._items, ...items];
+            return items;
+        }
+        catch (error) {
+            console.error('PageDataLoader: failed to load page', error);
+            return [];
+        }
+    };
+    reset = async () => {
+        this.pageNumber = 1;
+        this._items = [];
+        this.canLoadMore = true;
+        await this.loadMore();
+    };
+}

package/dist/core/deferred.d.ts

@@ -0,0 +1,6 @@
+export declare class Deferred<T = void> {
+    promise: Promise<T>;
+    reject: (reason?: unknown) => void;
+    resolve: (value: T) => void;
+    constructor();
+}

package/dist/core/deferred.js

@@ -0,0 +1,13 @@
+export class Deferred {
+    promise;
+    reject;
+    resolve;
+    constructor() {
+        this.resolve = () => ({});
+        this.reject = () => ({});
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
+}

package/dist/core/event-dispatcher.d.ts

@@ -0,0 +1,9 @@
+export declare class EventDispatcher {
+    static dispatch: <T extends AppEvent>(event: T) => void;
+    static subscribe: <T extends AppEvent>(eventType: new (...params: never[]) => T, handler: (event: T) => void) => (() => void);
+}
+export declare abstract class AppEvent {
+    constructor();
+    get classId(): string;
+    set classId(value: string);
+}

package/dist/core/event-dispatcher.js

@@ -0,0 +1,28 @@
+import { randomNanoid } from './utils/string-generator';
+export class EventDispatcher {
+    static dispatch = (event) => {
+        const appEvent = new CustomEvent(event.classId, { detail: event });
+        document.dispatchEvent(appEvent);
+    };
+    static subscribe = (eventType, handler) => {
+        const handlerFunc = (ev) => {
+            handler(ev.detail);
+        };
+        const classId = new eventType().classId;
+        document.addEventListener(classId, handlerFunc);
+        return () => document.removeEventListener(classId, handlerFunc);
+    };
+}
+export class AppEvent {
+    constructor() {
+        if (!this.classId) {
+            this.classId = randomNanoid();
+        }
+    }
+    get classId() {
+        return this.constructor.prototype._uniqueClassId;
+    }
+    set classId(value) {
+        this.constructor.prototype._uniqueClassId = value;
+    }
+}

package/dist/core/files/base64-helper.d.ts

@@ -0,0 +1,4 @@
+export declare class Base64Helper {
+    static getMimeType(base64: string): string;
+    static getBase64Data(base64: string): string;
+}

package/dist/core/files/base64-helper.js

@@ -0,0 +1,22 @@
+export class Base64Helper {
+    static getMimeType(base64) {
+        if (!base64 || !base64.startsWith('data:')) {
+            return null;
+        }
+        const end = base64.indexOf(';');
+        if (end === -1) {
+            return null;
+        }
+        return base64.slice(5, end);
+    }
+    static getBase64Data(base64) {
+        if (!base64) {
+            return null;
+        }
+        if (!base64.startsWith('data:')) {
+            return base64;
+        }
+        const start = base64.indexOf(',');
+        return base64.slice(start + 1);
+    }
+}

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

@@ -0,0 +1 @@
+export declare const uploadBlob: (sasUrl: string, blob: Blob, onProgress?: (uploaded: number, total: number) => void) => Promise<void>;

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

@@ -0,0 +1,19 @@
+export const uploadBlob = async (sasUrl, blob, onProgress = () => { }) => {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('PUT', sasUrl, true);
+        xhr.upload.addEventListener('progress', (event) => {
+            onProgress(event.loaded, event.total);
+        });
+        xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                resolve();
+            }
+            else {
+                reject(new Error(xhr.statusText || 'Request failed'));
+            }
+        };
+        xhr.onerror = () => reject(new Error('Network error'));
+        xhr.send(blob);
+    });
+};

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

@@ -0,0 +1,6 @@
+export declare class FileHelper {
+    static blobToFile(blob: Blob, fileName: string): File;
+    static getFileExtension(fileName: string): string;
+    static omitFileExtension(fileName: string): string;
+    static truncateFileName(fileName: string, maxNameLength: number | null | undefined): string;
+}

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

@@ -0,0 +1,27 @@
+import { StringHelper } from '../utils';
+export class FileHelper {
+    static blobToFile(blob, fileName) {
+        return new File([blob], fileName, { type: blob.type });
+    }
+    static getFileExtension(fileName) {
+        const name = StringHelper.isUrl(fileName) ? fileName.split('?')[0] : fileName;
+        const dotIndex = name.lastIndexOf('.');
+        return dotIndex > 0 ? name.slice(dotIndex + 1) : '';
+    }
+    static omitFileExtension(fileName) {
+        if (!fileName) {
+            return '';
+        }
+        const dotIndex = fileName.lastIndexOf('.');
+        return dotIndex > 0 ? fileName.slice(0, dotIndex) : fileName;
+    }
+    static truncateFileName(fileName, maxNameLength) {
+        if (!maxNameLength) {
+            return fileName;
+        }
+        const extension = FileHelper.getFileExtension(fileName);
+        const nameWithoutExt = FileHelper.omitFileExtension(fileName);
+        const truncatedName = nameWithoutExt.length > maxNameLength ? nameWithoutExt.slice(0, maxNameLength) + '..' : nameWithoutExt;
+        return extension ? `${truncatedName}.${extension}` : truncatedName;
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare const fetchFile: (url: string, fileName?: string) => Promise<File | null>;
+export declare const downloadJson: (data: unknown, fileName?: string) => void;
+export declare const downloadFromUrl: (url: string, fileName: string) => Promise<boolean>;
+export declare const downloadBlob: (blob: Blob, fileName: string) => void;

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

@@ -0,0 +1,54 @@
+import { nanoid } from 'nanoid';
+const SANITIZE_FILENAME_REGEX = /[\\/:"*?<>|]/g;
+const sanitizeFilename = (name) => {
+    return name.replace(SANITIZE_FILENAME_REGEX, '_');
+};
+export const fetchFile = async (url, fileName) => {
+    let validatedUrl;
+    try {
+        validatedUrl = new URL(url).toString();
+    }
+    catch {
+        console.error(`Invalid URL: ${url}`);
+        return null;
+    }
+    try {
+        const response = await fetch(validatedUrl, { cache: 'no-store' });
+        if (!response.ok) {
+            console.error(`Failed to fetch file: ${url} (HTTP ${response.status})`);
+            return null;
+        }
+        const blob = await response.blob();
+        const nameFromUrl = url.split('/').pop()?.split('?')[0] || undefined;
+        const name = sanitizeFilename(fileName ?? nameFromUrl ?? nanoid(15));
+        return new File([blob], name, {
+            type: blob.type,
+            lastModified: Date.now()
+        });
+    }
+    catch (error) {
+        console.error(`Failed to fetch file: ${url}`, error);
+        return null;
+    }
+};
+export const downloadJson = (data, fileName = 'data.json') => {
+    const json = JSON.stringify(data, null, 2);
+    const blob = new Blob([json], { type: 'application/json' });
+    downloadBlob(blob, fileName);
+};
+export const downloadFromUrl = async (url, fileName) => {
+    const file = await fetchFile(url, fileName);
+    if (!file) {
+        return false;
+    }
+    downloadBlob(file, fileName);
+    return true;
+};
+export const downloadBlob = (blob, fileName) => {
+    const blobUrl = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = blobUrl;
+    a.download = sanitizeFilename(fileName);
+    a.click();
+    URL.revokeObjectURL(blobUrl);
+};

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

@@ -0,0 +1,16 @@
+export declare class AcceptFileType {
+    static readonly any = "*/*";
+    static readonly image = "image/png,image/jpeg,image/webp";
+    static readonly video = "video/mp4";
+    static readonly audio = "audio/wav,audio/mpeg,audio/mp4,audio/aac,audio/aacp,audio/flac";
+    static readonly file: string;
+    static readonly archive = "application/zip";
+    static readonly imageOrVideo: string;
+    static readonly anyMedia: string;
+    static readonly anySupported: string;
+    static readonly webAssetImage: string;
+    static readonly webAssetVideo = "video/mp4";
+    static readonly webAssetImageOrVideo: string;
+    static readonly webAssetIcon = "image/png";
+}
+export declare const matchesAcceptedFileTypes: (file: File, acceptedTypesAndExtensions: string) => boolean;

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

@@ -0,0 +1,28 @@
+import { FileHelper } from './file-helper';
+export class AcceptFileType {
+    static any = '*/*';
+    static image = 'image/png,image/jpeg,image/webp';
+    static video = 'video/mp4';
+    static audio = 'audio/wav,audio/mpeg,audio/mp4,audio/aac,audio/aacp,audio/flac';
+    static file = 'application/pdf,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,' +
+        'application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,text/csv';
+    static archive = 'application/zip';
+    static imageOrVideo = [this.image, this.video].join(',');
+    static anyMedia = [this.image, this.video, this.audio].join(',');
+    static anySupported = [this.image, this.video, this.file].join(',');
+    static webAssetImage = [this.image, 'image/svg+xml'].join(',');
+    static webAssetVideo = this.video;
+    static webAssetImageOrVideo = [this.webAssetImage, this.webAssetVideo].join(',');
+    static webAssetIcon = 'image/png';
+}
+export const matchesAcceptedFileTypes = (file, acceptedTypesAndExtensions) => {
+    const isValid = AcceptFileType.anySupported.split(',').includes(file.type);
+    if (acceptedTypesAndExtensions) {
+        const acceptanceArray = acceptedTypesAndExtensions.split(',');
+        const extensions = acceptanceArray.filter((x) => x.startsWith('.'));
+        const fileExt = '.' + FileHelper.getFileExtension(file.name);
+        const fileTypes = acceptanceArray.filter((x) => !x.startsWith('.'));
+        return (extensions.includes(fileExt) || fileTypes.includes(file.type)) && isValid;
+    }
+    return isValid;
+};

package/dist/core/files/file-with-blob-data-helper.d.ts

@@ -0,0 +1,19 @@
+import { type BlobWithName, type FileWithBlobUrl } from './types';
+type FileGenerationOptions = {
+    id?: string;
+    maxNameLength?: number;
+};
+export declare class FileWithBlobDataHelper {
+    static fromBase64(base64: string, options?: FileGenerationOptions & {
+        name?: string;
+    }): FileWithBlobUrl;
+    static fromBlob(blob: Blob | BlobWithName, options?: FileGenerationOptions): FileWithBlobUrl;
+    static fromFile(file: File, options?: FileGenerationOptions): FileWithBlobUrl;
+    static fromUrl(url: string, options?: FileGenerationOptions & {
+        explicitName?: string;
+    }): Promise<FileWithBlobUrl | null>;
+    static fromUrlAnonymous(url: string, options?: FileGenerationOptions): Promise<FileWithBlobUrl | null>;
+    static dispose(blobUrl: string): void;
+    private static ensureFileWithValidName;
+}
+export {};

package/dist/core/files/file-with-blob-data-helper.js

@@ -0,0 +1,86 @@
+import { Base64Helper } from './base64-helper';
+import { FileHelper } from './file-helper';
+import { fetchFile } from './file-service';
+import { toBlobWithName } from './types';
+import { default as mime } from 'mime';
+import { nanoid } from 'nanoid';
+export class FileWithBlobDataHelper {
+    static fromBase64(base64, options) {
+        const binStr = window.atob(Base64Helper.getBase64Data(base64));
+        const len = binStr.length;
+        const arr = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            arr[i] = binStr.charCodeAt(i);
+        }
+        let blob = new Blob([arr], { type: Base64Helper.getMimeType(base64) });
+        if (options?.name) {
+            blob = toBlobWithName(blob, options.name);
+        }
+        return FileWithBlobDataHelper.fromBlob(blob, options);
+    }
+    static fromBlob(blob, options) {
+        if (blob instanceof File) {
+            return FileWithBlobDataHelper.fromFile(blob, options);
+        }
+        const extension = mime.getExtension(blob.type);
+        const fileName = 'name' in blob ? blob.name : `${nanoid(options?.maxNameLength || 15)}.${extension}`;
+        const file = FileHelper.blobToFile(blob, fileName);
+        return FileWithBlobDataHelper.fromFile(file, options);
+    }
+    static fromFile(file, options) {
+        const id = options?.id || nanoid(options?.maxNameLength || 15);
+        const validFile = FileWithBlobDataHelper.ensureFileWithValidName(file, options?.maxNameLength);
+        const result = validFile;
+        result.blobUrl = URL.createObjectURL(validFile);
+        result.id = id;
+        return result;
+    }
+    static async fromUrl(url, options) {
+        const file = await fetchFile(url, options?.explicitName);
+        if (!file) {
+            return null;
+        }
+        const maxNameLength = options?.maxNameLength || options?.explicitName?.length;
+        return FileWithBlobDataHelper.fromFile(file, { ...options, maxNameLength });
+    }
+    static async fromUrlAnonymous(url, options) {
+        return new Promise((resolve) => {
+            const img = new Image();
+            img.crossOrigin = 'anonymous';
+            img.onload = async () => {
+                const canvas = document.createElement('canvas');
+                canvas.width = img.width;
+                canvas.height = img.height;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    console.error('Failed to get canvas context');
+                    return resolve(null);
+                }
+                ctx.drawImage(img, 0, 0);
+                const dataUrl = canvas.toDataURL('image/png', 0.7);
+                const file = await FileWithBlobDataHelper.fromUrl(dataUrl, options);
+                resolve(file);
+            };
+            img.onerror = () => {
+                console.error(`Failed to load image: ${url}`);
+                resolve(null);
+            };
+            img.src = url;
+        });
+    }
+    static dispose(blobUrl) {
+        try {
+            URL.revokeObjectURL(blobUrl);
+        }
+        catch {
+            // ignore
+        }
+    }
+    static ensureFileWithValidName(file, maxNameLength) {
+        const truncatedName = FileHelper.truncateFileName(file.name, maxNameLength);
+        if (truncatedName !== file.name) {
+            return FileHelper.blobToFile(file, truncatedName);
+        }
+        return file;
+    }
+}