@loj-lang/rdsl-runtime 0.5.0

package/dist/hooks/navigation.js

@@ -0,0 +1,135 @@
+let configuredAppBasePath = '/';
+export function normalizeAppBasePath(value) {
+    if (!value) {
+        return '/';
+    }
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === '/') {
+        return '/';
+    }
+    const prefixed = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    return prefixed.endsWith('/') ? prefixed.slice(0, -1) || '/' : prefixed;
+}
+export function configureAppBasePath(value) {
+    configuredAppBasePath = normalizeAppBasePath(value);
+}
+export function getConfiguredAppBasePath() {
+    return configuredAppBasePath;
+}
+export function prefixAppBasePath(path) {
+    if (!path.startsWith('/')) {
+        return path;
+    }
+    const basePath = getConfiguredAppBasePath();
+    if (basePath === '/') {
+        return path;
+    }
+    if (path === basePath || path.startsWith(`${basePath}/`)) {
+        return path;
+    }
+    if (path === '/') {
+        return basePath;
+    }
+    return `${basePath}${path}`;
+}
+export function stripAppBasePath(pathname) {
+    const normalizedPathname = pathname && pathname.startsWith('/') ? pathname : `/${pathname || ''}`;
+    const basePath = getConfiguredAppBasePath();
+    if (basePath === '/') {
+        return normalizedPathname === '' ? '/' : normalizedPathname;
+    }
+    if (normalizedPathname === basePath) {
+        return '/';
+    }
+    if (normalizedPathname.startsWith(`${basePath}/`)) {
+        return normalizedPathname.slice(basePath.length) || '/';
+    }
+    return normalizedPathname === '' ? '/' : normalizedPathname;
+}
+export function getCurrentAppPathname() {
+    if (typeof window === 'undefined')
+        return '/';
+    return stripAppBasePath(window.location.pathname);
+}
+export function getCurrentAppHref() {
+    if (typeof window === 'undefined')
+        return '/';
+    return `${window.location.pathname}${window.location.search}`;
+}
+export function getLocationSearchParams() {
+    if (typeof window === 'undefined')
+        return null;
+    return new URLSearchParams(window.location.search);
+}
+export function shiftDateInputValue(value, days) {
+    const trimmed = String(value ?? '').trim();
+    const match = trimmed.match(/^(\d{4})([-/])(\d{2})\2(\d{2})$/);
+    if (!match) {
+        return trimmed;
+    }
+    const [, yearText, separator, monthText, dayText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
+        return trimmed;
+    }
+    const date = new Date(Date.UTC(year, month - 1, day));
+    if (Number.isNaN(date.getTime())
+        || date.getUTCFullYear() !== year
+        || date.getUTCMonth() !== month - 1
+        || date.getUTCDate() !== day) {
+        return trimmed;
+    }
+    date.setUTCDate(date.getUTCDate() + days);
+    const nextYear = String(date.getUTCFullYear()).padStart(4, '0');
+    const nextMonth = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const nextDay = String(date.getUTCDate()).padStart(2, '0');
+    return `${nextYear}${separator}${nextMonth}${separator}${nextDay}`;
+}
+function scopedSearchParamKey(prefix, key) {
+    return prefix ? `${prefix}.${key}` : key;
+}
+export function getLocationSearchValues(defaultValues, options = {}) {
+    const params = options.searchParams ?? getLocationSearchParams();
+    const nextValues = { ...defaultValues };
+    for (const key of Object.keys(defaultValues)) {
+        const value = params?.get(scopedSearchParamKey(options.prefix, key));
+        if (value !== null && value !== undefined) {
+            nextValues[key] = value;
+        }
+    }
+    return nextValues;
+}
+export function replaceLocationSearchValues(values, options = {}) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const keys = options.keys ?? Object.keys(values);
+    const params = new URLSearchParams(window.location.search);
+    for (const key of keys) {
+        const value = String(values[key] ?? '');
+        const scopedKey = scopedSearchParamKey(options.prefix, key);
+        if (value.trim() === '') {
+            params.delete(scopedKey);
+        }
+        else {
+            params.set(scopedKey, value);
+        }
+    }
+    const nextSearch = params.toString();
+    const nextHref = `${window.location.pathname}${nextSearch ? `?${nextSearch}` : ''}${window.location.hash}`;
+    const currentHref = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+    if (nextHref !== currentHref) {
+        window.history.replaceState(window.history.state, '', nextHref);
+    }
+}
+export function sanitizeAppLocalHref(candidate) {
+    if (!candidate || !candidate.startsWith('/') || candidate.startsWith('//'))
+        return null;
+    return candidate;
+}
+export function getSanitizedReturnTo(searchParams) {
+    const params = searchParams ?? getLocationSearchParams();
+    return sanitizeAppLocalHref(params?.get('returnTo'));
+}

package/dist/hooks/resourceClient.d.ts

@@ -0,0 +1,36 @@
+export interface ResourceClient {
+    get<T>(path: string): Promise<T>;
+    list<T extends {
+        id: string;
+    }>(api: string): Promise<T[]>;
+    create<T extends {
+        id: string;
+    }>(api: string, input: Partial<T>): Promise<T>;
+    update<T extends {
+        id: string;
+    }>(api: string, id: string, input: Partial<T>): Promise<T>;
+    delete(api: string, id: string): Promise<void>;
+    post<T>(path: string, input?: unknown): Promise<T>;
+}
+export interface ResourceProviderProps {
+    client: ResourceClient;
+    children?: React.ReactNode;
+}
+export interface FetchResourceClientOptions {
+    baseUrl?: string;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    credentials?: RequestCredentials;
+    fetch?: typeof fetch;
+}
+export declare function normalizeListPayload<T extends {
+    id: string;
+}>(payload: unknown, api: string): T[];
+export declare function normalizeRecordPayload<T extends {
+    id: string;
+}>(payload: unknown, api: string, operation: string): T;
+export declare function createFetchResourceClient(options?: FetchResourceClientOptions): ResourceClient;
+export declare function createMemoryResourceClient(): ResourceClient;
+export declare function ResourceProvider({ client, children }: ResourceProviderProps): any;
+export declare function useResourceClient(): ResourceClient;
+export declare function resetResourceClientTestState(): void;
+//# sourceMappingURL=resourceClient.d.ts.map

package/dist/hooks/resourceClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceClient.d.ts","sourceRoot":"","sources":["../../src/hooks/resourceClient.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjC,IAAI,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1D,MAAM,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7E,MAAM,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACzF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IACnE,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AA2DD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC3D,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,GACV,CAAC,EAAE,CAcL;AAED,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC7D,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GAChB,CAAC,CAQH;AA4CD,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,cAAc,CAkFlG;AAED,wBAAgB,0BAA0B,IAAI,cAAc,CAwC3D;AAqCD,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,qBAAqB,OAE3E;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAIlD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD"}

package/dist/hooks/resourceClient.js

@@ -0,0 +1,259 @@
+import React from 'react';
+const ResourceClientContext = React.createContext(undefined);
+const memoryCollections = new Map();
+const fetchClientCache = new Map();
+let sameOriginFetchClient = null;
+let defaultMemoryClient = null;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function resourceLeaf(api) {
+    const parts = api.split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? 'record';
+}
+function createSyntheticId(api, collection) {
+    const id = `${resourceLeaf(api)}-${collection.nextId}`;
+    collection.nextId += 1;
+    return id;
+}
+function ensureMemoryCollection(api) {
+    const existing = memoryCollections.get(api);
+    if (existing)
+        return existing;
+    const created = {
+        items: [],
+        nextId: 1,
+    };
+    memoryCollections.set(api, created);
+    return created;
+}
+function withStringId(payload, api, operation) {
+    if (!isRecord(payload) || payload.id === undefined || payload.id === null) {
+        throw new Error(`Invalid ${operation} response for ${api}: expected a record with an id`);
+    }
+    return {
+        ...payload,
+        id: String(payload.id),
+    };
+}
+export function normalizeListPayload(payload, api) {
+    const items = Array.isArray(payload)
+        ? payload
+        : isRecord(payload) && Array.isArray(payload.items)
+            ? payload.items
+            : isRecord(payload) && Array.isArray(payload.data)
+                ? payload.data
+                : null;
+    if (!items) {
+        throw new Error(`Invalid list response for ${api}: expected an array or { items: [] }`);
+    }
+    return items.map((item) => withStringId(item, api, 'list'));
+}
+export function normalizeRecordPayload(payload, api, operation) {
+    const record = isRecord(payload) && isRecord(payload.item)
+        ? payload.item
+        : isRecord(payload) && isRecord(payload.data)
+            ? payload.data
+            : payload;
+    return withStringId(record, api, operation);
+}
+async function resolveHeaders(headers) {
+    if (!headers)
+        return undefined;
+    return typeof headers === 'function' ? await headers() : headers;
+}
+function mergeHeaders(...headerSets) {
+    const merged = new Headers();
+    for (const headerSet of headerSets) {
+        if (!headerSet)
+            continue;
+        const next = new Headers(headerSet);
+        next.forEach((value, key) => {
+            merged.set(key, value);
+        });
+    }
+    return merged;
+}
+function resolveResourceUrl(api, baseUrl) {
+    if (/^https?:\/\//i.test(api))
+        return api;
+    if (!baseUrl || baseUrl.trim() === '')
+        return api;
+    const normalizedBase = baseUrl.trim();
+    if (!/^https?:\/\//i.test(normalizedBase)) {
+        return api;
+    }
+    const absoluteBase = normalizedBase.endsWith('/') ? normalizedBase : `${normalizedBase}/`;
+    return new URL(api.startsWith('/') ? api.slice(1) : api, absoluteBase).toString();
+}
+async function readJsonPayload(response, api, method) {
+    const text = await response.text();
+    if (text.trim() === '')
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON response for ${method} ${api}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function createFetchResourceClient(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== 'function') {
+        throw new Error('Fetch is not available; provide options.fetch or use ResourceProvider with a custom client');
+    }
+    async function request(method, api, init = {}) {
+        const requestHeaders = mergeHeaders(await resolveHeaders(options.headers), init.headers);
+        const response = await fetchImpl(resolveResourceUrl(api, options.baseUrl), {
+            ...init,
+            method,
+            credentials: options.credentials,
+            headers: requestHeaders,
+        });
+        const payload = await readJsonPayload(response, api, method);
+        if (!response.ok) {
+            const detail = isRecord(payload) && typeof payload.message === 'string'
+                ? `: ${payload.message}`
+                : '';
+            throw new Error(`${method} ${api} failed with ${response.status}${detail}`);
+        }
+        return payload;
+    }
+    return {
+        async get(path) {
+            const payload = await request('GET', path);
+            return payload;
+        },
+        async list(api) {
+            const payload = await request('GET', api);
+            return normalizeListPayload(payload, api);
+        },
+        async create(api, input) {
+            const payload = await request('POST', api, {
+                body: JSON.stringify(input),
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            });
+            return normalizeRecordPayload(payload, api, 'create');
+        },
+        async update(api, id, input) {
+            const payload = await request('PUT', `${api}/${encodeURIComponent(id)}`, {
+                body: JSON.stringify(input),
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (payload === undefined) {
+                return {
+                    ...input,
+                    id: String(id),
+                };
+            }
+            return normalizeRecordPayload(payload, api, 'update');
+        },
+        async delete(api, id) {
+            await request('DELETE', `${api}/${encodeURIComponent(id)}`);
+        },
+        async post(path, input) {
+            const payload = await request('POST', path, {
+                body: input === undefined ? undefined : JSON.stringify(input),
+                headers: {
+                    Accept: 'application/json',
+                    ...(input === undefined ? {} : { 'Content-Type': 'application/json' }),
+                },
+            });
+            return payload;
+        },
+    };
+}
+export function createMemoryResourceClient() {
+    return {
+        async get(path) {
+            const [collectionPath] = path.split('?');
+            return ensureMemoryCollection(collectionPath).items.map((item) => ({ ...item }));
+        },
+        async list(api) {
+            return ensureMemoryCollection(api).items.map((item) => ({ ...item }));
+        },
+        async create(api, input) {
+            const collection = ensureMemoryCollection(api);
+            const nextRecord = {
+                ...input,
+                id: String(input.id ?? createSyntheticId(api, collection)),
+            };
+            collection.items = [...collection.items, nextRecord];
+            return { ...nextRecord };
+        },
+        async update(api, id, input) {
+            const collection = ensureMemoryCollection(api);
+            const current = collection.items.find((item) => item.id === id);
+            if (!current) {
+                throw new Error(`Record not found: ${id}`);
+            }
+            const nextRecord = {
+                ...current,
+                ...input,
+                id,
+            };
+            collection.items = collection.items.map((item) => item.id === id ? nextRecord : item);
+            return { ...nextRecord };
+        },
+        async delete(api, id) {
+            const collection = ensureMemoryCollection(api);
+            collection.items = collection.items.filter((item) => item.id !== id);
+        },
+        async post(_path, _input) {
+            throw new Error('Memory resource client does not support custom POST actions');
+        },
+    };
+}
+function readGlobalResourceClient() {
+    if (typeof window === 'undefined')
+        return undefined;
+    const value = window.__RDSL_RESOURCE_CLIENT__;
+    return value && typeof value === 'object' ? value : undefined;
+}
+function readGlobalApiBase() {
+    if (typeof window === 'undefined')
+        return undefined;
+    const value = window.__RDSL_API_BASE__;
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function getDefaultResourceClient() {
+    const globalBase = readGlobalApiBase();
+    if (globalBase) {
+        const existing = fetchClientCache.get(globalBase);
+        if (existing)
+            return existing;
+        const created = createFetchResourceClient({ baseUrl: globalBase });
+        fetchClientCache.set(globalBase, created);
+        return created;
+    }
+    if (typeof globalThis.fetch === 'function') {
+        if (!sameOriginFetchClient) {
+            sameOriginFetchClient = createFetchResourceClient();
+        }
+        return sameOriginFetchClient;
+    }
+    if (!defaultMemoryClient) {
+        defaultMemoryClient = createMemoryResourceClient();
+    }
+    return defaultMemoryClient;
+}
+export function ResourceProvider({ client, children }) {
+    return React.createElement(ResourceClientContext.Provider, { value: client }, children);
+}
+export function useResourceClient() {
+    return React.useContext(ResourceClientContext)
+        ?? readGlobalResourceClient()
+        ?? getDefaultResourceClient();
+}
+export function resetResourceClientTestState() {
+    memoryCollections.clear();
+    fetchClientCache.clear();
+    sameOriginFetchClient = null;
+    defaultMemoryClient = null;
+}

package/dist/hooks/resourceStore.d.ts

@@ -0,0 +1,25 @@
+import type { ResourceClient } from './resourceClient.js';
+export interface ResourceStoreSnapshot<T extends {
+    id: string;
+}> {
+    items: T[];
+    error: unknown;
+    pendingCount: number;
+    resolvedOnce: boolean;
+}
+export interface ResourceStore<T extends {
+    id: string;
+}> {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): ResourceStoreSnapshot<T>;
+    getById(id: string): T | undefined;
+    load(force?: boolean): Promise<T[]>;
+    createItem(input: Partial<T>): Promise<T>;
+    updateItem(id: string, input: Partial<T>): Promise<T>;
+    deleteItem(id: string): Promise<void>;
+}
+export declare function getResourceStore<T extends {
+    id: string;
+}>(client: ResourceClient, api: string): ResourceStore<T>;
+export declare function resetResourceStoreTestState(): void;
+//# sourceMappingURL=resourceStore.d.ts.map

package/dist/hooks/resourceStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceStore.d.ts","sourceRoot":"","sources":["../../src/hooks/resourceStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IAC7D,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IACrD,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5C,WAAW,IAAI,qBAAqB,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACpC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAkLD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EACvD,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,MAAM,GACV,aAAa,CAAC,CAAC,CAAC,CAOlB;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAGlD"}

package/dist/hooks/resourceStore.js

@@ -0,0 +1,164 @@
+const resourceStores = new Map();
+const resourceClientIds = new WeakMap();
+let nextClientId = 1;
+function storeKey(client, api) {
+    const resourceClient = client;
+    let id = resourceClientIds.get(resourceClient);
+    if (!id) {
+        id = nextClientId;
+        nextClientId += 1;
+        resourceClientIds.set(resourceClient, id);
+    }
+    return `${id}:${api}`;
+}
+function notifyState(state) {
+    for (const listener of state.listeners) {
+        listener();
+    }
+}
+function resourceLeaf(api) {
+    const parts = api.split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? 'record';
+}
+function syncNextId(api, state) {
+    const prefix = `${resourceLeaf(api)}-`;
+    let max = 0;
+    for (const item of state.items) {
+        if (!item.id.startsWith(prefix))
+            continue;
+        const suffix = Number(item.id.slice(prefix.length));
+        if (Number.isFinite(suffix) && suffix > max) {
+            max = suffix;
+        }
+    }
+    state.nextId = max + 1;
+}
+function createSyntheticId(api, state) {
+    const id = `${resourceLeaf(api)}-${state.nextId}`;
+    state.nextId += 1;
+    return id;
+}
+function createResourceStore(client, api) {
+    const state = {
+        items: [],
+        listeners: new Set(),
+        error: null,
+        pendingCount: 0,
+        resolvedOnce: false,
+        inFlightLoad: null,
+        nextId: 1,
+    };
+    async function runMutation(mutate) {
+        state.pendingCount += 1;
+        state.error = null;
+        notifyState(state);
+        try {
+            const result = await mutate();
+            state.resolvedOnce = true;
+            return result;
+        }
+        catch (error) {
+            state.error = error;
+            state.resolvedOnce = true;
+            throw error;
+        }
+        finally {
+            state.pendingCount = Math.max(0, state.pendingCount - 1);
+            notifyState(state);
+        }
+    }
+    return {
+        subscribe(listener) {
+            state.listeners.add(listener);
+            return () => {
+                state.listeners.delete(listener);
+            };
+        },
+        getSnapshot() {
+            return {
+                items: state.items,
+                error: state.error,
+                pendingCount: state.pendingCount,
+                resolvedOnce: state.resolvedOnce,
+            };
+        },
+        getById(id) {
+            return state.items.find((item) => item.id === id);
+        },
+        load(force = false) {
+            if (!force && state.resolvedOnce && !state.error) {
+                return Promise.resolve(state.items);
+            }
+            if (state.inFlightLoad) {
+                return state.inFlightLoad;
+            }
+            state.pendingCount += 1;
+            state.error = null;
+            notifyState(state);
+            state.inFlightLoad = client.list(api)
+                .then((items) => {
+                state.items = [...items];
+                state.error = null;
+                state.resolvedOnce = true;
+                syncNextId(api, state);
+                return state.items;
+            })
+                .catch((error) => {
+                state.error = error;
+                state.resolvedOnce = true;
+                throw error;
+            })
+                .finally(() => {
+                state.pendingCount = Math.max(0, state.pendingCount - 1);
+                state.inFlightLoad = null;
+                notifyState(state);
+            });
+            return state.inFlightLoad;
+        },
+        createItem(input) {
+            return runMutation(async () => {
+                const created = await client.create(api, input);
+                const nextRecord = {
+                    ...created,
+                    id: String(created.id ?? createSyntheticId(api, state)),
+                };
+                state.items = [...state.items, nextRecord];
+                syncNextId(api, state);
+                return nextRecord;
+            });
+        },
+        updateItem(id, input) {
+            return runMutation(async () => {
+                const current = state.items.find((item) => item.id === id);
+                const updated = await client.update(api, id, input);
+                const nextRecord = {
+                    ...current,
+                    ...input,
+                    ...updated,
+                    id: String(updated.id ?? id),
+                };
+                state.items = state.items.map((item) => item.id === id ? nextRecord : item);
+                return nextRecord;
+            });
+        },
+        deleteItem(id) {
+            return runMutation(async () => {
+                await client.delete(api, id);
+                state.items = state.items.filter((item) => item.id !== id);
+            });
+        },
+    };
+}
+export function getResourceStore(client, api) {
+    const key = storeKey(client, api);
+    const existing = resourceStores.get(key);
+    if (existing)
+        return existing;
+    const created = createResourceStore(client, api);
+    resourceStores.set(key, created);
+    return created;
+}
+export function resetResourceStoreTestState() {
+    resourceStores.clear();
+    nextClientId = 1;
+}

package/dist/hooks/resourceTarget.d.ts

@@ -0,0 +1,2 @@
+export declare function matchesResourceTarget(api: string, target: unknown): boolean;
+//# sourceMappingURL=resourceTarget.d.ts.map

package/dist/hooks/resourceTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceTarget.d.ts","sourceRoot":"","sources":["../../src/hooks/resourceTarget.ts"],"names":[],"mappings":"AAUA,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAa3E"}

package/dist/hooks/resourceTarget.js

@@ -0,0 +1,22 @@
+function normalizeTarget(target) {
+    return target.trim().replace(/^\/+|\/+$/g, '');
+}
+function apiLeaf(api) {
+    const normalized = normalizeTarget(api);
+    const parts = normalized.split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? normalized;
+}
+export function matchesResourceTarget(api, target) {
+    if (typeof target !== 'string' || target.trim() === '')
+        return false;
+    const normalizedTarget = normalizeTarget(target);
+    const normalizedApi = normalizeTarget(api);
+    const leaf = apiLeaf(api);
+    return [
+        normalizedApi,
+        leaf,
+        `${leaf}.list`,
+        `resource.${leaf}`,
+        `resource.${leaf}.list`,
+    ].includes(normalizedTarget);
+}

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,16 @@
+export interface AuthUser {
+    id?: string;
+    role?: string;
+    [key: string]: unknown;
+}
+export interface AuthState {
+    currentUser: AuthUser | null;
+}
+interface AuthProviderProps {
+    value: AuthState;
+    children?: React.ReactNode;
+}
+export declare function AuthProvider({ value, children }: AuthProviderProps): any;
+export declare function useAuth(): AuthState;
+export {};
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/hooks/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC9B;AAED,UAAU,iBAAiB;IACzB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAiBD,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,iBAAiB,OAElE;AAED,wBAAgB,OAAO,IAAI,SAAS,CAEnC"}