@intent-framework/core 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export type { AskNode, AnyAskNode, AskKind, AskBuilder } from "./ask.js";
 export type { ActNode, ActCondition, ActStatus, FeedbackConfig, ActBuilder, NavigationService, ActionExecutionContext, DefaultScreenServices } from "./act.js";
 export type { FlowNode, FlowStep, FlowBuilder } from "./flow.js";
 export type { SurfaceNode, SurfaceBuilder } from "./surface.js";
-export type { ResourceNode, ResourceConfig, ResourceCacheOptions, ResourceLoadContext, ResourceStatus, AnyResourceNode } from "./resource.js";
+export type { ResourceNode, ResourceConfig, ResourceCacheOptions, ResourceLoadContext, ResourceStatus, ResourceKey, AnyResourceNode } from "./resource.js";
 export { ResourceRef, createResourceNode } from "./resource.js";
 export { createScreenRuntime } from "./runtime.js";
 export type { ScreenRuntime } from "./runtime.js";

package/dist/index.js

@@ -40,13 +40,26 @@ function signal(initial) {
 function createResourceNode(id, name, loader, autoLoad = true, cache) {
 	const statusSignal = signal(0);
 	const staleSignal = signal(0);
+	const hasKey = typeof cache?.key === "function";
+	const DEFAULT_KEY = "";
+	function createEntry() {
+		return {
+			value: void 0,
+			status: "idle",
+			error: void 0,
+			stale: false,
+			staleTimer: null,
+			inFlightPromise: null
+		};
+	}
+	const entries = /* @__PURE__ */ new Map();
+	let _activeKey = DEFAULT_KEY;
+	if (!hasKey) entries.set(DEFAULT_KEY, createEntry());
 	let currentStatus = "idle";
 	let currentValue = void 0;
 	let currentError = void 0;
 	let currentStale = false;
 	let lastContext = void 0;
-	let _staleTimer = null;
-	let _inFlightPromise = null;
 	const notify = () => statusSignal.set(statusSignal.get() + 1);
 	const staleNotify = () => staleSignal.set(staleSignal.get() + 1);
 	const shouldDeduplicate = cache ? cache.deduplicate !== false : false;
@@ -54,6 +67,69 @@ function createResourceNode(id, name, loader, autoLoad = true, cache) {
 	let _pending;
 	let _failed;
 	let _stale;
+	function getActiveEntry() {
+		let entry = entries.get(_activeKey);
+		if (!entry) {
+			entry = createEntry();
+			entries.set(_activeKey, entry);
+		}
+		return entry;
+	}
+	function syncFromEntry(entry) {
+		currentStatus = entry.status;
+		currentValue = entry.value;
+		currentError = entry.error;
+		if (currentStale !== entry.stale) {
+			currentStale = entry.stale;
+			staleNotify();
+		}
+		notify();
+	}
+	function syncFromActiveEntry() {
+		syncFromEntry(getActiveEntry());
+	}
+	function encodeResourceKey(key) {
+		if (Array.isArray(key)) return ["array", key.map(encodeResourceKey)];
+		if (key === null) return ["null"];
+		if (key === void 0) return ["undefined"];
+		if (typeof key === "string") return ["string", key];
+		if (typeof key === "boolean") return ["boolean", key];
+		if (typeof key === "number") {
+			if (Number.isNaN(key)) return ["number", "NaN"];
+			if (key === Infinity) return ["number", "Infinity"];
+			if (key === -Infinity) return ["number", "-Infinity"];
+			if (Object.is(key, -0)) return ["number", "-0"];
+			return ["number", key];
+		}
+		const exhaustive = key;
+		return exhaustive;
+	}
+	function normalizeKey(key) {
+		return JSON.stringify(encodeResourceKey(key));
+	}
+	function resolveKey(ctx) {
+		if (!hasKey) return DEFAULT_KEY;
+		const context = ctx ?? lastContext ?? {};
+		return normalizeKey(cache.key(context));
+	}
+	function _clearEntryStaleTimer(entry) {
+		if (entry.staleTimer != null) {
+			clearTimeout(entry.staleTimer);
+			entry.staleTimer = null;
+		}
+	}
+	function _startEntryStaleTimer(entry) {
+		_clearEntryStaleTimer(entry);
+		if (cache?.staleTime != null && isFinite(cache.staleTime)) entry.staleTimer = setTimeout(() => {
+			if (!entry.stale) {
+				entry.stale = true;
+				if (entry === getActiveEntry()) {
+					currentStale = true;
+					staleNotify();
+				}
+			}
+		}, cache.staleTime);
+	}
 	function getReady() {
 		if (!_ready) _ready = createCondition(() => currentStatus === "ready", (notify$1) => statusSignal.subscribe(() => notify$1()));
 		return _ready;
@@ -70,62 +146,59 @@ function createResourceNode(id, name, loader, autoLoad = true, cache) {
 		if (!_stale) _stale = createCondition(() => currentStale, (notify$1) => staleSignal.subscribe(() => notify$1()));
 		return _stale;
 	}
-	function _clearStaleTimer() {
-		if (_staleTimer != null) {
-			clearTimeout(_staleTimer);
-			_staleTimer = null;
-		}
-	}
-	function _startStaleTimer() {
-		_clearStaleTimer();
-		if (cache?.staleTime != null && isFinite(cache.staleTime)) _staleTimer = setTimeout(() => {
-			if (!currentStale) {
-				currentStale = true;
-				staleNotify();
-			}
-		}, cache.staleTime);
-	}
 	function executeLoad(context) {
-		if (shouldDeduplicate && _inFlightPromise) return _inFlightPromise;
-		currentStale = false;
-		staleNotify();
-		currentStatus = "pending";
-		currentValue = void 0;
-		currentError = void 0;
-		notify();
+		const key = resolveKey(context);
+		_activeKey = key;
+		let entry = entries.get(key);
+		if (!entry) {
+			entry = createEntry();
+			entries.set(key, entry);
+		}
+		if (shouldDeduplicate && entry.inFlightPromise) return entry.inFlightPromise;
 		if (context !== void 0) lastContext = context;
 		const loadContext = context ?? lastContext ?? {};
+		entry.stale = false;
+		entry.status = "pending";
+		entry.value = void 0;
+		entry.error = void 0;
+		syncFromActiveEntry();
 		const promise = (async () => {
 			try {
 				const result = await Promise.resolve(loader(loadContext));
-				currentValue = result;
-				currentStatus = "ready";
-				currentStale = false;
-				notify();
+				entry.value = result;
+				entry.status = "ready";
+				entry.stale = false;
+				if (entry === getActiveEntry()) syncFromEntry(entry);
 				staleNotify();
-				_startStaleTimer();
+				_startEntryStaleTimer(entry);
 			} catch (e) {
-				currentError = e;
-				currentStatus = "failed";
-				currentStale = false;
-				notify();
+				entry.error = e;
+				entry.status = "failed";
+				entry.stale = false;
+				if (entry === getActiveEntry()) syncFromEntry(entry);
 				staleNotify();
 			} finally {
-				_inFlightPromise = null;
+				entry.inFlightPromise = null;
 			}
 		})();
-		_inFlightPromise = promise;
+		entry.inFlightPromise = promise;
 		return promise;
 	}
 	function invalidate() {
-		if (!currentStale) {
-			currentStale = true;
-			staleNotify();
+		const entry = getActiveEntry();
+		if (!entry.stale) {
+			entry.stale = true;
+			if (entry === getActiveEntry()) {
+				currentStale = true;
+				staleNotify();
+			}
 		}
 	}
 	function dispose() {
-		_clearStaleTimer();
-		_inFlightPromise = null;
+		for (const entry of entries.values()) {
+			_clearEntryStaleTimer(entry);
+			entry.inFlightPromise = null;
+		}
 	}
 	const node = {
 		id,

package/dist/resource.d.ts

@@ -1,6 +1,7 @@
 import { type Condition } from "./signal.js";
 import type { ActionExecutionContext, DefaultScreenServices } from "./act.js";
 export type ResourceStatus = "idle" | "pending" | "ready" | "failed";
+export type ResourceKey = string | number | boolean | null | undefined | ResourceKey[];
 export type ResourceLoadContext<TServices extends object = DefaultScreenServices> = ActionExecutionContext<TServices>;
 type ResourceLoader<TValue, TServices extends object> = (() => TValue | Promise<TValue>) | ((context: ResourceLoadContext<TServices>) => TValue | Promise<TValue>);
 export type ResourceNode<TValue, TServices extends object = DefaultScreenServices> = {
@@ -21,7 +22,8 @@ export type ResourceNode<TValue, TServices extends object = DefaultScreenService
     dispose: () => void;
 };
 export type AnyResourceNode = ResourceNode<unknown, any>;
-export type ResourceCacheOptions = {
+export type ResourceCacheOptions<TServices extends object = DefaultScreenServices> = {
+    key?: (context: ResourceLoadContext<TServices>) => ResourceKey;
     staleTime?: number;
     deduplicate?: boolean;
 };
@@ -30,11 +32,11 @@ export type ResourceConfig<TValue = unknown, TServices extends object = DefaultS
     name: string;
     autoLoad: boolean;
     loader: ResourceLoader<TValue, TServices>;
-    cache?: ResourceCacheOptions;
+    cache?: ResourceCacheOptions<TServices>;
     ref?: ResourceRef<TValue, TServices>;
 };
 export declare function createResourceConfig<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean): ResourceConfig<TValue, TServices>;
-export declare function createResourceNode<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean, cache?: ResourceCacheOptions): ResourceNode<TValue, TServices>;
+export declare function createResourceNode<TValue, TServices extends object = DefaultScreenServices>(id: string, name: string, loader: ResourceLoader<TValue, TServices>, autoLoad?: boolean, cache?: ResourceCacheOptions<TServices>): ResourceNode<TValue, TServices>;
 export declare class ResourceRef<TValue, TServices extends object = DefaultScreenServices> {
     readonly id: string;
     readonly name: string;

package/dist/screen.d.ts

@@ -31,7 +31,7 @@ export type ScreenBuilder<TServices extends object = DefaultScreenServices> = {
     resource: <T>(name: string, config: {
         load: (() => Promise<T>) | ((context: ResourceLoadContext<TServices>) => Promise<T>);
         autoLoad?: boolean;
-        cache?: ResourceCacheOptions;
+        cache?: ResourceCacheOptions<TServices>;
     }) => ResourceRef<T, TServices>;
 };
 export type ScreenDefinition<TServices extends object = DefaultScreenServices> = {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.9",
   "description": "Platformless semantic graph and runtime for Intent applications",
   "license": "MIT",
   "repository": {