dalila 1.8.2 → 1.8.4

package/dist/core/resource.js

@@ -1,4 +1,4 @@
-import { signal, effectAsync } from "./signal.js";
+import { signal, effect, effectAsync } from "./signal.js";
 import { isInDevMode } from "./dev.js";
 import { getCurrentScope, createScope, isScopeDisposed, withScope } from "./scope.js";
 function createDeferred() {
@@ -33,7 +33,7 @@ function createDeferred() {
  *   - dispose the driver
  *   - resolve all pending waiters (avoid hanging Promises)
  */
-export function createResource(fetchFn, options = {}) {
+function createResourceBase(fetchFn, options = {}) {
     const data = signal(options.initialValue ?? null);
     const loading = signal(false);
     const error = signal(null);
@@ -154,6 +154,152 @@ export function createResource(fetchFn, options = {}) {
     }
     return { data, loading, error, refresh };
 }
+function normalizeResourceCachePolicy(cache) {
+    if (!cache)
+        return null;
+    if (typeof cache === "string")
+        return { key: cache };
+    return cache;
+}
+function attachResourceRefreshInterval(resource, refreshInterval) {
+    const scope = getCurrentScope();
+    if (!scope) {
+        if (isInDevMode()) {
+            console.warn(`[Dalila] createResource(..., { refreshInterval }) called outside a scope. ` +
+                `Auto-refresh will not work. Use within a scope or manage cleanup manually.`);
+        }
+        return;
+    }
+    const intervalId = setInterval(() => {
+        resource.refresh().catch(() => { });
+    }, refreshInterval);
+    scope.onCleanup(() => {
+        clearInterval(intervalId);
+    });
+}
+function enqueueForcedRefresh(resource) {
+    queueMicrotask(() => {
+        resource.refresh({ force: true }).catch(() => { });
+    });
+}
+function createDynamicCachedResource(fetchFn, cachePolicy, options) {
+    const ownerScope = getCurrentScope();
+    const rawKey = cachePolicy.key;
+    const keyGetter = typeof rawKey === "function"
+        ? rawKey
+        : () => rawKey;
+    const deps = options.deps;
+    const cachedOptions = {
+        initialValue: options.initialValue,
+        onError: options.onError,
+        onSuccess: options.onSuccess,
+        ttlMs: cachePolicy.ttlMs,
+        tags: cachePolicy.tags,
+        persist: cachePolicy.persist,
+    };
+    let activeKey = null;
+    let activeKeyScope = null;
+    let activeResource = null;
+    const activeResourceSignal = signal(null);
+    let first = true;
+    const activateKey = (key) => {
+        if (activeResource && activeKey === key) {
+            return activeResource;
+        }
+        if (ownerScope) {
+            activeKeyScope?.dispose();
+            const keyScope = createScope(ownerScope);
+            activeKeyScope = keyScope;
+            activeResource = withScope(keyScope, () => createCachedResource(key, fetchFn, cachedOptions));
+        }
+        else {
+            // Outside a scope, createCachedResource already applies safe-by-default semantics.
+            activeResource = createCachedResource(key, fetchFn, cachedOptions);
+        }
+        activeKey = key;
+        activeResourceSignal.set(activeResource);
+        return activeResource;
+    };
+    effect(() => {
+        if (deps)
+            deps();
+        const key = keyGetter();
+        const previousKey = activeKey;
+        const resource = activateKey(key);
+        // If deps changed but key stayed the same, revalidate current entry.
+        if (!first && deps && previousKey === key) {
+            enqueueForcedRefresh(resource);
+        }
+        if (first) {
+            first = false;
+        }
+    });
+    if (ownerScope) {
+        ownerScope.onCleanup(() => {
+            activeKeyScope?.dispose();
+            activeKeyScope = null;
+        });
+    }
+    return {
+        data: () => activeResourceSignal()?.data() ?? null,
+        loading: () => activeResourceSignal()?.loading() ?? false,
+        error: () => activeResourceSignal()?.error() ?? null,
+        refresh: (opts) => activeResourceSignal()?.refresh(opts) ?? Promise.resolve(),
+    };
+}
+export function createResource(fetchFn, options = {}) {
+    const { deps, refreshInterval } = options;
+    const cachePolicy = normalizeResourceCachePolicy(options.cache);
+    const fetchFnForCached = deps
+        ? async (signal) => {
+            // Keep deps ownership explicit (via options.deps) when cache is enabled.
+            // This avoids duplicate revalidations from sync reads inside fetchFn.
+            await Promise.resolve();
+            return fetchFn(signal);
+        }
+        : fetchFn;
+    const baseOptions = {
+        initialValue: options.initialValue,
+        onError: options.onError,
+        onSuccess: options.onSuccess,
+    };
+    let resource;
+    if (cachePolicy) {
+        const key = cachePolicy.key;
+        if (typeof key === "function") {
+            resource = createDynamicCachedResource(fetchFnForCached, cachePolicy, options);
+        }
+        else {
+            resource = createCachedResource(key, fetchFnForCached, {
+                ...baseOptions,
+                ttlMs: cachePolicy.ttlMs,
+                tags: cachePolicy.tags,
+                persist: cachePolicy.persist,
+            });
+            if (deps) {
+                let first = true;
+                effect(() => {
+                    deps();
+                    if (first) {
+                        first = false;
+                        return;
+                    }
+                    enqueueForcedRefresh(resource);
+                });
+            }
+        }
+    }
+    else if (deps) {
+        resource = createDependentResource((signal) => fetchFn(signal), deps, baseOptions);
+    }
+    else {
+        resource = createResourceBase(fetchFn, baseOptions);
+    }
+    if (refreshInterval != null && refreshInterval > 0) {
+        attachResourceRefreshInterval(resource, refreshInterval);
+    }
+    return resource;
+}
 /**
  * Fetch helper built on top of createResource().
  *
@@ -162,18 +308,22 @@ export function createResource(fetchFn, options = {}) {
  * - Uses fetch() with AbortSignal.
  * - Non-2xx responses throw (surfaced via resource.error()).
  */
-export function createFetchResource(url, options = {}) {
+function createFetchResource(url, options = {}) {
+    return resourceFromUrl(url, options);
+}
+export function resourceFromUrl(url, options = {}) {
+    const { fetchOptions, ...resourceOptions } = options;
     return createResource(async (signal) => {
         const fetchUrl = typeof url === "function" ? url() : url;
         const response = await fetch(fetchUrl, {
-            ...options.fetchOptions,
+            ...fetchOptions,
             signal,
         });
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);
         }
         return (await response.json());
-    }, options);
+    }, resourceOptions);
 }
 /**
  * Resource that revalidates when dependencies change.
@@ -196,7 +346,7 @@ export function createFetchResource(url, options = {}) {
  *   we must not resolve refresh waiters prematurely.
  *   Guard: early-return resolves only if `!loading()`.
  */
-export function createDependentResource(fetchFn, deps, options = {}) {
+function createDependentResource(fetchFn, deps, options = {}) {
     const data = signal(options.initialValue ?? null);
     const loading = signal(false);
     const error = signal(null);
@@ -440,7 +590,7 @@ function evictIfNeeded() {
  * - Each entry has a dedicated cacheScope, disposed when the entry is removed.
  * - Scopes referencing an entry increment refCount; on scope cleanup they release it.
  */
-export function createCachedResource(key, fetchFn, options = {}) {
+function createCachedResource(key, fetchFn, options = {}) {
     const scope = getCurrentScope();
     const fetchScope = options.fetchScope && !isScopeDisposed(options.fetchScope) ? options.fetchScope : null;
     const wrappedFetch = fetchScope
@@ -462,7 +612,7 @@ export function createCachedResource(key, fetchFn, options = {}) {
                     `No caching will happen. Use persist: true (or q.queryGlobal) for global cache.`);
             }
         }
-        return createResource(wrappedFetch, options);
+        return createResourceBase(wrappedFetch, options);
     }
     const now = Date.now();
     const existing = resourceCache.get(key);
@@ -509,7 +659,7 @@ export function createCachedResource(key, fetchFn, options = {}) {
      * Create the resource inside cacheScope so its subscriptions, effects, and abort handling
      * belong to the cache entry itself.
      */
-    const resource = withScope(cacheScope, () => createResource(wrappedFetch, options));
+    const resource = withScope(cacheScope, () => createResourceBase(wrappedFetch, options));
     const entry = {
         resource,
         createdAt: now,
@@ -533,7 +683,7 @@ export function createCachedResource(key, fetchFn, options = {}) {
 /**
  * Convenience wrapper: builds the cache key from an id.
  */
-export function createCachedResourceById(id, keyFn, fetchFn, options = {}) {
+function createCachedResourceById(id, keyFn, fetchFn, options = {}) {
     const key = keyFn(id);
     return createCachedResource(key, (sig) => fetchFn(sig, id), options);
 }
@@ -698,9 +848,9 @@ function removeCacheKey(key) {
  * - Requires a scope so the interval can be cleaned up automatically.
  * - Outside a scope, it warns and returns a normal resource (no interval).
  */
-export function createAutoRefreshResource(fetchFn, refreshInterval, options = {}) {
+function createAutoRefreshResource(fetchFn, refreshInterval, options = {}) {
     const scope = getCurrentScope();
-    const resource = createResource(fetchFn, options);
+    const resource = createResourceBase(fetchFn, options);
     if (!scope) {
         if (isInDevMode()) {
             console.warn(`[Dalila] createAutoRefreshResource called outside a scope. ` +
@@ -716,7 +866,20 @@ export function createAutoRefreshResource(fetchFn, refreshInterval, options = {}
     });
     return resource;
 }
-export function createIsolatedCache() {
+export function createResourceCache(config = {}) {
+    const isolated = createIsolatedCache();
+    isolated.configure(config);
+    return {
+        create: isolated.createCachedResource,
+        clear: isolated.clearCache,
+        invalidate: isolated.invalidateKey,
+        invalidateTag: isolated.invalidateTag,
+        invalidateTags: isolated.invalidateTags,
+        keys: () => Array.from(isolated.getCache().keys()),
+        configure: isolated.configure,
+    };
+}
+function createIsolatedCache() {
     // Isolated state
     const isolatedCache = new Map();
     const isolatedTagIndex = new Map();
@@ -828,7 +991,7 @@ export function createIsolatedCache() {
                 console.warn(`[Dalila] createCachedResource("${key}") called outside a scope. ` +
                     `No caching will happen. Use persist: true for global cache.`);
             }
-            return createResource(wrappedFetch, options);
+            return createResourceBase(wrappedFetch, options);
         }
         const now = Date.now();
         const existing = isolatedCache.get(key);
@@ -860,7 +1023,7 @@ export function createIsolatedCache() {
             }
         }
         const cacheScope = createScope(null);
-        const resource = withScope(cacheScope, () => createResource(wrappedFetch, options));
+        const resource = withScope(cacheScope, () => createResourceBase(wrappedFetch, options));
         const entry = {
             resource,
             createdAt: now,

package/dist/form/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./form-types.js";
-export { createForm, parseFormData, WRAPPED_HANDLER } from "./form.js";
+export { createForm, parseFormData } from "./form.js";

package/dist/form/index.js

@@ -1,2 +1,2 @@
 export * from "./form-types.js";
-export { createForm, parseFormData, WRAPPED_HANDLER } from "./form.js";
+export { createForm, parseFormData } from "./form.js";

package/dist/router/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./router.js";
+export { createRouter, createTypedNavigate, type RouterStatus, type Router, type ScrollBehavior, type LifecycleHooks, type RouterConfig, type RouteTagContext, type RouterPreloadCacheEntry, type TypedNavigate, } from "./router.js";
 export * from "./route-tables.js";

package/dist/router/index.js

@@ -1,2 +1,2 @@
-export * from "./router.js";
+export { createRouter, createTypedNavigate, } from "./router.js";
 export * from "./route-tables.js";

package/dist/runtime/bind.d.ts

@@ -15,6 +15,16 @@ export interface BindOptions {
      * Selectors for elements where text interpolation should be skipped
      */
     rawTextSelectors?: string;
+    /**
+     * Optional runtime cache policy for text interpolation template plans.
+     * Defaults are tuned for general SPA usage.
+     */
+    templatePlanCache?: {
+        /** Maximum number of cached template plans (0 disables cache). */
+        maxEntries?: number;
+        /** Time-to-live (ms) per plan, refreshed on hit (0 disables cache). */
+        ttlMs?: number;
+    };
     /**
      * Internal flag — set by fromHtml for router/template rendering.
      * Skips HMR context registration but KEEPS d-ready/d-loading lifecycle.