firstly 0.0.15 → 0.0.16-next.0

package/esm/svelte/FF_Repo.svelte.js

@@ -0,0 +1,170 @@
+import { repo as remultRepo, } from 'remult';
+import { Log } from '@kitql/helpers';
+import { tryCatch, tryCatchSync } from './';
+export class FF_Repo {
+    ent;
+    #repo;
+    #paginator;
+    #findOptions;
+    #queryOptions;
+    fields;
+    metadata;
+    loading = $state({
+        init: false,
+        fetching: false,
+        more: false,
+        saving: false,
+        deleting: false,
+    });
+    items = $state(undefined);
+    aggregates = $state(undefined);
+    hasNextPage = $state(undefined);
+    item = $state(undefined);
+    // errors = $state<ErrorInfo<Entity> | undefined>(undefined)
+    globalError = $state(undefined);
+    loadingEnd = (toRet) => {
+        this.loading = {
+            init: false,
+            fetching: false,
+            more: false,
+            saving: false,
+            deleting: false,
+        };
+        return toRet;
+    };
+    constructor(ent, o) {
+        this.ent = ent;
+        this.#repo = remultRepo(ent);
+        this.fields = this.#repo.fields;
+        this.metadata = this.#repo.metadata;
+        this.#paginator = undefined;
+        this.#findOptions = o?.findOptions;
+        this.#queryOptions = o?.queryOptions;
+        this.item = o?.item;
+        if (o?.findOptions !== undefined && !o.findOptions.skipAutoFetch) {
+            this.loading.init = true;
+            this.find(o.findOptions);
+        }
+        else if (o?.queryOptions !== undefined && !o.queryOptions.skipAutoFetch) {
+            this.loading.init = true;
+            this.query(o.queryOptions);
+        }
+        else {
+            this.loadingEnd();
+        }
+    }
+    async find(options) {
+        this.loading.fetching = true;
+        const { data, error } = await tryCatch(this.#repo.find({
+            ...this.#findOptions,
+            ...options,
+        }));
+        if (error) {
+            this.globalError = error.message;
+            return this.loadingEnd();
+        }
+        this.items = data;
+        return this.loadingEnd(data);
+    }
+    async query(options) {
+        this.loading = {
+            ...this.loading,
+            fetching: true,
+            init: this.items === undefined,
+        };
+        // REMULT P1: add test for dynamic orderBy in remult
+        //            Looks like only the default orderby of the entity is working
+        const { data: queryResult, error: queryResultError } = tryCatchSync(() => this.#repo.query({
+            pageSize: 2,
+            ...this.#queryOptions,
+            ...options,
+            // Yes, we always want to aggregate to get at least the $count!
+            // And empty object is giving us that
+            aggregate: {
+                ...this.#queryOptions?.aggregate,
+            },
+        }));
+        if (queryResultError) {
+            this.globalError = queryResultError.message;
+            return this.loadingEnd();
+        }
+        const { data: paginator, error: paginatorError } = await tryCatch(queryResult.paginator());
+        if (paginatorError) {
+            this.globalError = paginatorError.message;
+            return this.loadingEnd();
+        }
+        this.#paginator = paginator;
+        this.items = this.#paginator.items;
+        // @ts-expect-error - We know the structure will match due to how we define the types
+        this.aggregates = this.#paginator.aggregates;
+        this.hasNextPage = this.#paginator.hasNextPage && this.aggregates.$count > this.items.length;
+        return this.loadingEnd({
+            items: this.items,
+            aggregates: this.aggregates,
+            hasNextPage: this.hasNextPage,
+        });
+    }
+    async queryMore() {
+        if (this.#paginator === undefined) {
+            new Log('FF_Repo').error('No paginator found');
+            return undefined;
+        }
+        if (this.loading.more) {
+            // already in progress...
+            return undefined;
+        }
+        this.loading = {
+            ...this.loading,
+            fetching: true,
+            more: true,
+        };
+        const { data: nextPage, error: nextPageError } = await tryCatch(this.#paginator.nextPage());
+        if (nextPageError) {
+            this.globalError = nextPageError.message;
+            return this.loadingEnd();
+        }
+        this.#paginator = nextPage;
+        this.items?.push(...nextPage.items);
+        this.hasNextPage = this.#paginator.hasNextPage && this.aggregates.$count > this.items.length;
+        return this.loadingEnd({
+            items: this.items,
+            aggregates: this.aggregates,
+            hasNextPage: this.hasNextPage,
+        });
+    }
+    create(...args) {
+        this.item = this.#repo.create(...args);
+        return this.item;
+    }
+    async delete(...args) {
+        this.loading.deleting = true;
+        await this.#repo.delete(...args);
+        // REMULT P4: return the deleted item ?
+        if (typeof args[0] === 'string') {
+            this.items = this.items?.filter((i) => this.metadata.idMetadata.getId(i) !== args[0]);
+        }
+        else {
+            this.items = this.items?.filter((i) => this.metadata.idMetadata.getId(i) !== this.metadata.idMetadata.getId(args[0]));
+        }
+        if (this.aggregates) {
+            this.aggregates.$count = this.aggregates.$count - 1;
+        }
+        return this.loadingEnd();
+    }
+    getLayout = (o) => {
+        const layout = this.metadata.options.ui?.getLayout?.(o);
+        if (layout) {
+            return layout;
+        }
+        return {
+            key: o?.key ?? 'default',
+            type: o?.type ?? 'grid',
+            groups: [
+                {
+                    key: o?.key ?? 'default',
+                    fields: this.#repo.fields.toArray().filter((c) => c.apiUpdateAllowed()),
+                },
+            ],
+        };
+    };
+}

package/esm/svelte/actions/intersection.d.ts

@@ -0,0 +1,6 @@
+import type { Action } from 'svelte/action';
+interface Attributes {
+    onintersecting: (e: CustomEvent<IntersectionObserverEntry>) => void;
+}
+export declare const intersection: Action<HTMLElement, IntersectionObserverInit | undefined, Attributes>;
+export {};

package/esm/svelte/actions/intersection.js

@@ -0,0 +1,17 @@
+import { getScrollParent } from '@layerstack/utils';
+// to bring back to https://github.com/techniq/layerstack/blob/main/packages/svelte-actions/src/lib/observer.ts to have correct typing in Svelte 5
+export const intersection = (node, options = {}) => {
+    const scrollParent = getScrollParent(node);
+    // Use viewport (null) if scrollParent = `<body>`
+    const root = scrollParent === document.body ? null : scrollParent;
+    const observer = new IntersectionObserver((entries, observer) => {
+        const entry = entries[0];
+        node.dispatchEvent(new CustomEvent('intersecting', { detail: entry }));
+    }, { root, ...options });
+    observer.observe(node);
+    return {
+        destroy() {
+            observer.disconnect();
+        },
+    };
+};

package/esm/svelte/class/SP.svelte.d.ts

@@ -0,0 +1,61 @@
+import { goto } from '$app/navigation';
+type ParamType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export interface ParamDefinition<TValue> {
+    type?: ParamType;
+    /** Alternative key to use in URL search params */
+    key?: string;
+    /** Custom function to convert value to URL string (for storage in URL only) */
+    encode?: (obj: TValue) => string | undefined;
+    /** Custom function to parse URL value to the correct type (for internal use) */
+    decode?: (str: string | undefined) => TValue;
+    /** Debounce the URL update for this parameter (milliseconds or true for default) */
+    debounce?: number | boolean;
+}
+/**
+ * SearchParams class for handling URL search parameters with Svelte 5 runes
+ * Provides automatic binding and URL updates
+ */
+export declare class SP<T extends Record<string, any>> {
+    private defaults;
+    private options;
+    private paramValues;
+    private debouncedValues;
+    computing: boolean;
+    private debouncedToURL;
+    private sharedDebouncePending;
+    private activeDebounces;
+    private longestDebounceTime;
+    private finalizeDebounce;
+    private _obj;
+    get obj(): T;
+    get computed(): T;
+    get rawStr(): Record<keyof T, string | undefined>;
+    private config;
+    private keyMap;
+    /**
+     * Create a new SearchParams instance
+     * @param defaults Object with default values (also defines the structure of type T)
+     * @param options Object containing parameter definitions and configuration
+     */
+    constructor(defaults: T, options?: {
+        config?: Partial<{
+            [K in keyof T]: Partial<ParamDefinition<T[K]>>;
+        }>;
+        gotoOpts?: Parameters<typeof goto>[1];
+    });
+    /**
+     * Load parameter values from URL
+     * Always store the decoded objects, not the URL string representations
+     */
+    private fromURL;
+    /**
+     * Update URL with current parameter values
+     * Only uses encoding for URL representation, doesn't modify internal state
+     */
+    private toURL;
+    /**
+     * Reset all parameters to their default values
+     */
+    reset(): void;
+}
+export {};

package/esm/svelte/class/SP.svelte.js

@@ -0,0 +1,412 @@
+// FIXME
+// Why packages/ui pnpm check fails with goto and page?
+//   - OK it's not a sveltekit project... But this is never used! So why is it checking it ?!
+// @ts-ignore
+import { goto } from '$app/navigation';
+// @ts-ignore
+import { page } from '$app/state';
+import { debounce } from '../helpers/debounce.js';
+const CONFIG_DELIMITER = ';';
+/**
+ * SearchParams class for handling URL search parameters with Svelte 5 runes
+ * Provides automatic binding and URL updates
+ */
+export class SP {
+    defaults;
+    options;
+    // Internal state container - always stores decoded objects
+    paramValues = $state({});
+    // Track debounced values separately - also always decoded objects
+    debouncedValues = $state({});
+    // Flag indicating when debouncing is active
+    computing = $state(false);
+    // Store debounced toURL functions for each parameter
+    debouncedToURL = {};
+    // Shared debounce mechanism for all parameters
+    sharedDebouncePending = $state(false);
+    activeDebounces = $state({});
+    longestDebounceTime = $state(0);
+    // This will be called after all individual debounces have completed
+    finalizeDebounce = () => {
+        // Only proceed if all tracked debounces have completed
+        if (Object.values(this.activeDebounces).some((active) => active)) {
+            return;
+        }
+        // Apply all pending changes
+        for (const key of Object.keys(this.paramValues)) {
+            this.debouncedValues[key] = this.paramValues[key];
+        }
+        // Update URL and reset flags
+        this.sharedDebouncePending = false;
+        this.computing = false;
+        this.longestDebounceTime = 0;
+        this.toURL();
+    };
+    // Created proxy object for direct param access
+    _obj = {};
+    // Expose public properties via getters
+    get obj() {
+        return this._obj;
+    }
+    get computed() {
+        return this._obj.computed;
+    }
+    get rawStr() {
+        return this._obj.rawStr;
+    }
+    // Config for each param, with defaults applied
+    config;
+    // Maps from URL key to object key
+    keyMap = {};
+    /**
+     * Create a new SearchParams instance
+     * @param defaults Object with default values (also defines the structure of type T)
+     * @param options Object containing parameter definitions and configuration
+     */
+    constructor(defaults, options = {}) {
+        this.defaults = defaults;
+        this.options = options;
+        // Initialize definitions from defaults
+        this.config = {};
+        // Create definitions based on default values
+        for (const [key, value] of Object.entries(defaults)) {
+            // Determine the type based on the default value
+            let type = 'string';
+            if (typeof value === 'number')
+                type = 'number';
+            else if (typeof value === 'boolean')
+                type = 'boolean';
+            else if (Array.isArray(value))
+                type = 'array';
+            else if (typeof value === 'object' && value !== null)
+                type = 'object';
+            // Create base definition
+            this.config[key] = {
+                type,
+            };
+        }
+        // Apply custom definitions on top of auto-generated ones
+        if (options.config) {
+            for (const [key, def] of Object.entries(options.config)) {
+                if (this.config[key]) {
+                    this.config[key] = {
+                        ...this.config[key],
+                        ...def,
+                    };
+                }
+            }
+        }
+        // Set keyMap
+        for (const [key, def] of Object.entries(this.config)) {
+            // Build key mapping for URL params
+            this.keyMap[key] = def.key || key;
+        }
+        // Initialize values from definitions with default values
+        // Always store the actual objects, not their string representations
+        for (const [key] of Object.entries(this.config)) {
+            this.paramValues[key] = defaults[key];
+            this.debouncedValues[key] = defaults[key];
+            this.activeDebounces[key] = false;
+            // Create debounced functions for each parameter that needs it
+            const def = this.config[key];
+            if (def.debounce) {
+                const delay = typeof def.debounce === 'number' ? def.debounce : 444;
+                this.debouncedToURL[key] = debounce(() => {
+                    // Mark this specific debounce as complete
+                    this.activeDebounces[key] = false;
+                    // Check if this is the last active debounce
+                    this.finalizeDebounce();
+                }, delay);
+            }
+        }
+        // Create the nested structure for obj.computed and obj.rawStr
+        this._obj.computed = {};
+        this._obj.rawStr = {};
+        // Create proxy object for direct parameter access
+        for (const key of Object.keys(this.config)) {
+            // Main parameter accessor - This always returns the decoded object
+            Object.defineProperty(this._obj, key, {
+                get: () => this.paramValues[key],
+                set: (value) => {
+                    // Always store the actual object value
+                    this.paramValues[key] = value;
+                    const def = this.config[key];
+                    if (def.debounce) {
+                        // Start computing
+                        this.computing = true;
+                        // Track this debounce
+                        const delay = typeof def.debounce === 'number' ? def.debounce : 444;
+                        this.activeDebounces[key] = true;
+                        this.sharedDebouncePending = true;
+                        // Track the longest debounce time
+                        if (delay > this.longestDebounceTime) {
+                            this.longestDebounceTime = delay;
+                        }
+                        // Trigger individual debounce
+                        if (this.debouncedToURL[key]) {
+                            this.debouncedToURL[key]();
+                        }
+                    }
+                    else {
+                        // No debounce for this parameter, update immediately
+                        this.debouncedValues[key] = value;
+                        // If there are no active debounces, just update right away
+                        if (!this.sharedDebouncePending) {
+                            this.toURL();
+                        }
+                    }
+                },
+                enumerable: true,
+            });
+            // Add debounced value accessor in the computed object
+            Object.defineProperty(this._obj.computed, key, {
+                get: () => this.debouncedValues[key],
+                enumerable: true,
+            });
+            // Add ID accessor in the rawStr object
+            Object.defineProperty(this._obj.rawStr, key, {
+                get: () => {
+                    const value = this.debouncedValues[key];
+                    const def = this.config[key];
+                    // Skip undefined or null values
+                    if (value === undefined || value === null) {
+                        return undefined;
+                    }
+                    // If there's a custom encode function, use it
+                    if (def.encode) {
+                        return def.encode(value);
+                    }
+                    // Otherwise use default conversion based on type
+                    switch (def.type) {
+                        case 'array':
+                            return Array.isArray(value) ? value.join(CONFIG_DELIMITER) : String(value);
+                        case 'object':
+                            return JSON.stringify(value);
+                        default:
+                            // Handle primitives
+                            return String(value);
+                    }
+                },
+                set: (idValue) => {
+                    const def = this.config[key];
+                    // If the ID is undefined, set the value to undefined
+                    if (idValue === undefined) {
+                        this.paramValues[key] = undefined;
+                        this.debouncedValues[key] = undefined;
+                        this.toURL();
+                        return;
+                    }
+                    // We need to convert the ID to the full object
+                    // If there's a decode function, we can use that
+                    if (def.decode) {
+                        // Use decode to convert from the string ID to the full object
+                        const fullObject = def.decode(idValue.toString());
+                        this.paramValues[key] = fullObject;
+                        this.debouncedValues[key] = fullObject;
+                        this.toURL();
+                    }
+                    else {
+                        // No decode function, just set the ID value directly
+                        let value = idValue;
+                        // Try to convert based on type
+                        switch (def.type) {
+                            case 'number':
+                                value = parseFloat(idValue.toString());
+                                if (isNaN(value))
+                                    value = idValue;
+                                break;
+                            case 'boolean':
+                                value = idValue === 'true';
+                                break;
+                            case 'array':
+                                if (typeof idValue === 'string') {
+                                    value = idValue.split(CONFIG_DELIMITER).filter(Boolean);
+                                }
+                                break;
+                            case 'object':
+                                if (typeof idValue === 'string') {
+                                    try {
+                                        value = JSON.parse(idValue);
+                                    }
+                                    catch (e) {
+                                        console.error(`Error parsing JSON for param ${key}:`, e);
+                                        value = idValue;
+                                    }
+                                }
+                                break;
+                        }
+                        this.paramValues[key] = value;
+                        this.debouncedValues[key] = value;
+                        this.toURL();
+                    }
+                },
+                enumerable: true,
+            });
+        }
+        // Load values from URL after setting up the structure
+        this.fromURL();
+    }
+    /**
+     * Load parameter values from URL
+     * Always store the decoded objects, not the URL string representations
+     */
+    fromURL() {
+        const params = page.url.searchParams;
+        for (const [propKey, tmpDef] of Object.entries(this.config)) {
+            const def = tmpDef;
+            const urlKey = this.keyMap[propKey]; // Get the URL parameter key
+            const paramValue = params.get(urlKey);
+            if (paramValue !== null) {
+                // If there is a decode function, always use it to get the proper object
+                if (def.decode) {
+                    const decodedValue = def.decode(paramValue);
+                    this.paramValues[propKey] = decodedValue;
+                    this.debouncedValues[propKey] = decodedValue;
+                    continue;
+                }
+                // Otherwise use default conversion based on type
+                switch (def.type) {
+                    case 'number': {
+                        const num = parseFloat(paramValue);
+                        if (!isNaN(num)) {
+                            this.paramValues[propKey] = num;
+                            this.debouncedValues[propKey] = num;
+                        }
+                        break;
+                    }
+                    case 'boolean':
+                        this.paramValues[propKey] = paramValue === 'true';
+                        this.debouncedValues[propKey] = this.paramValues[propKey];
+                        break;
+                    case 'array':
+                        this.paramValues[propKey] = paramValue.split(CONFIG_DELIMITER).filter(Boolean);
+                        this.debouncedValues[propKey] = this.paramValues[propKey];
+                        break;
+                    case 'object':
+                        try {
+                            this.paramValues[propKey] = JSON.parse(paramValue);
+                            this.debouncedValues[propKey] = this.paramValues[propKey];
+                        }
+                        catch (e) {
+                            console.error(`Error parsing JSON for param ${propKey}:`, e);
+                            // Keep default value on error
+                        }
+                        break;
+                    case 'string':
+                    default:
+                        this.paramValues[propKey] = paramValue;
+                        this.debouncedValues[propKey] = paramValue;
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * Update URL with current parameter values
+     * Only uses encoding for URL representation, doesn't modify internal state
+     */
+    toURL() {
+        if (typeof window === 'undefined')
+            return;
+        // If there's a shared debounce pending, don't update URL yet
+        if (this.sharedDebouncePending) {
+            return;
+        }
+        const params = new URLSearchParams(window.location.search);
+        for (const [propKey, value] of Object.entries(this.debouncedValues)) {
+            // Skip undefined or null values
+            if (value === undefined || value === null) {
+                params.delete(this.keyMap[propKey]);
+                continue;
+            }
+            // Get the definition and URL key
+            const def = this.config[propKey];
+            if (!def)
+                continue;
+            const urlKey = this.keyMap[propKey];
+            const defaultValue = this.defaults[propKey];
+            // Encode the current value
+            let encodedValue;
+            if (def.encode) {
+                encodedValue = def.encode(value);
+                if (!encodedValue) {
+                    params.delete(urlKey);
+                    continue;
+                }
+            }
+            else {
+                // Otherwise use default conversion based on type
+                switch (def.type) {
+                    case 'array':
+                        encodedValue = Array.isArray(value) ? value.join(CONFIG_DELIMITER) : String(value);
+                        break;
+                    case 'object':
+                        encodedValue = JSON.stringify(value);
+                        break;
+                    default:
+                        // Handle primitives
+                        encodedValue = String(value);
+                        break;
+                }
+            }
+            // Encode the default value for comparison
+            let encodedDefault;
+            if (defaultValue !== undefined && defaultValue !== null) {
+                if (def.encode) {
+                    encodedDefault = def.encode(defaultValue);
+                }
+                else {
+                    switch (def.type) {
+                        case 'array':
+                            encodedDefault = Array.isArray(defaultValue)
+                                ? defaultValue.join(CONFIG_DELIMITER)
+                                : String(defaultValue);
+                            break;
+                        case 'object':
+                            encodedDefault = JSON.stringify(defaultValue);
+                            break;
+                        default:
+                            encodedDefault = String(defaultValue);
+                            break;
+                    }
+                }
+            }
+            // Skip values that match their encoded defaults
+            if (encodedValue === encodedDefault) {
+                params.delete(urlKey);
+                continue;
+            }
+            // Set the encoded value in URL
+            params.set(urlKey, encodedValue);
+        }
+        const strSearch = params.toString() ? '?' + params.toString() : '';
+        // Don't do the goto if the search params haven't changed!
+        if (strSearch === window.location.search)
+            return;
+        goto(`${window.location.pathname}${strSearch}`, {
+            keepFocus: true,
+            replaceState: true,
+            noScroll: true,
+            ...this.options.gotoOpts,
+        });
+        // Reset computing flag after URL update is complete
+        this.computing = false;
+    }
+    /**
+     * Reset all parameters to their default values
+     */
+    reset() {
+        // Reset both sets of values to defaults immediately
+        for (const [key] of Object.entries(this.config)) {
+            this.paramValues[key] = this.defaults[key];
+            this.debouncedValues[key] = this.defaults[key];
+            this.activeDebounces[key] = false;
+        }
+        // Cancel any pending debounce
+        this.sharedDebouncePending = false;
+        this.longestDebounceTime = 0;
+        // Update URL immediately without debounce
+        this.computing = false;
+        this.toURL();
+    }
+}