@zeus-js/resource 0.0.0-stage → 0.1.1-beta.14

package/dist/resource.cjs

@@ -0,0 +1,151 @@
+/**
+* resource v0.1.1-beta.14
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _zeus_js_signal = require("@zeus-js/signal");
+let _zeus_js_signal_internal = require("@zeus-js/signal/internal");
+//#region packages/core/resource/src/index.ts
+const primitiveKey = (value) => {
+	if (typeof value === "string") return `string:${value}`;
+	if (typeof value === "number") return `number:${value}`;
+	if (typeof value === "boolean") return `boolean:${value}`;
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	throw new Error("Resource source objects require an explicit options.key");
+};
+/**
+* Creates a single-owner async resource. Every request has a generation and
+* AbortSignal, so a late response cannot overwrite a newer result.
+*/
+function createResource(source, fetcher, options = {}) {
+	var _options$key;
+	const keyOf = (_options$key = options.key) !== null && _options$key !== void 0 ? _options$key : primitiveKey;
+	const cache = /* @__PURE__ */ new Map();
+	const [state, setState] = (0, _zeus_js_signal.createSignal)({
+		status: "pending",
+		pending: true,
+		success: false,
+		error: void 0,
+		data: options.initialData,
+		stale: options.initialData !== void 0,
+		updatedAt: void 0
+	});
+	let controller;
+	let generation = 0;
+	let disposed = false;
+	let lastSource;
+	const cancel = () => {
+		generation++;
+		controller === null || controller === void 0 || controller.abort();
+		controller = void 0;
+	};
+	const refetch = async () => {
+		if (disposed) throw new Error("Resource has been disposed");
+		const currentSource = lastSource;
+		const key = keyOf(currentSource);
+		const now = Date.now();
+		cancel();
+		const requestGeneration = ++generation;
+		const cached = cache.get(key);
+		if (cached && options.staleTime !== void 0 && now - cached.updatedAt < options.staleTime) {
+			setState({
+				status: "success",
+				pending: false,
+				success: true,
+				error: void 0,
+				data: cached.data,
+				stale: false,
+				updatedAt: cached.updatedAt
+			});
+			return cached.data;
+		}
+		const requestController = new AbortController();
+		controller = requestController;
+		const previous = state().data;
+		setState({
+			status: "pending",
+			pending: true,
+			success: false,
+			error: void 0,
+			data: previous,
+			stale: previous !== void 0,
+			updatedAt: state().updatedAt
+		});
+		try {
+			const data = await fetcher(currentSource, { signal: requestController.signal });
+			if (disposed || requestGeneration !== generation) throw new Error("Resource request became stale");
+			const updatedAt = Date.now();
+			cache.set(key, {
+				data,
+				updatedAt
+			});
+			setState({
+				status: "success",
+				pending: false,
+				success: true,
+				error: void 0,
+				data,
+				stale: false,
+				updatedAt
+			});
+			return data;
+		} catch (error) {
+			if (disposed || requestGeneration !== generation) throw error;
+			if (requestController.signal.aborted) setState({
+				...state(),
+				status: "pending",
+				pending: true,
+				success: false,
+				stale: state().data !== void 0
+			});
+			else setState({
+				...state(),
+				status: "error",
+				pending: false,
+				success: false,
+				error,
+				stale: state().data !== void 0
+			});
+			throw error;
+		} finally {
+			if (controller === requestController) controller = void 0;
+		}
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		cancel();
+		cache.clear();
+	};
+	const readSource = () => typeof source === "function" ? source() : source;
+	const load = () => {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	};
+	if (typeof source === "function" && (0, _zeus_js_signal_internal.getCurrentScope)()) (0, _zeus_js_signal.createEffect)(load);
+	else {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	}
+	if ((0, _zeus_js_signal_internal.getCurrentScope)()) (0, _zeus_js_signal.onCleanup)(dispose);
+	return {
+		state,
+		status: () => state().status,
+		pending: () => state().pending,
+		success: () => state().success,
+		error: () => state().error,
+		data: () => state().data,
+		stale: () => state().stale,
+		updatedAt: () => state().updatedAt,
+		refetch,
+		cancel,
+		dispose
+	};
+}
+//#endregion
+exports.createResource = createResource;

package/dist/resource.d.ts

@@ -0,0 +1,45 @@
+import { Accessor } from '@zeus-js/signal';
+
+export type ResourceStatus = 'pending' | 'success' | 'error';
+export interface ResourceState<T> {
+    readonly status: ResourceStatus;
+    readonly pending: boolean;
+    readonly success: boolean;
+    readonly error: unknown;
+    readonly data: T | undefined;
+    readonly stale: boolean;
+    readonly updatedAt: number | undefined;
+}
+export interface ResourceContext {
+    readonly signal: AbortSignal;
+}
+export interface ResourceOptions<K, T> {
+    /** Converts a source value into a cache key. Primitive keys are supported by default. */
+    key?: (source: K) => string;
+    /** Fresh results are reused until this many milliseconds have elapsed. */
+    staleTime?: number;
+    /** Optional value shown before the first successful request. */
+    initialData?: T;
+}
+export interface Resource<T> {
+    readonly state: Accessor<ResourceState<T>>;
+    readonly status: Accessor<ResourceStatus>;
+    readonly pending: Accessor<boolean>;
+    readonly success: Accessor<boolean>;
+    readonly error: Accessor<unknown>;
+    readonly data: Accessor<T | undefined>;
+    readonly stale: Accessor<boolean>;
+    readonly updatedAt: Accessor<number | undefined>;
+    /** Starts a request for the current source and cancels the previous one. */
+    refetch(): Promise<T>;
+    cancel(): void;
+    dispose(): void;
+}
+type Source<K> = K | Accessor<K>;
+/**
+ * Creates a single-owner async resource. Every request has a generation and
+ * AbortSignal, so a late response cannot overwrite a newer result.
+ */
+export declare function createResource<T, K>(source: Source<K>, fetcher: (source: K, context: ResourceContext) => Promise<T> | T, options?: ResourceOptions<K, T>): Resource<T>;
+
+

package/dist/resource.esm-bundler.js

@@ -0,0 +1,237 @@
+/**
+* resource v0.1.1-beta.14
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+import { createEffect, createSignal, onCleanup } from "@zeus-js/signal";
+import { getCurrentScope } from "@zeus-js/signal/internal";
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n) {
+		e(n);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+			}
+			function _throw(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+			}
+			_next(void 0);
+		});
+	};
+}
+//#endregion
+//#region packages/core/resource/src/index.ts
+const primitiveKey = (value) => {
+	if (typeof value === "string") return `string:${value}`;
+	if (typeof value === "number") return `number:${value}`;
+	if (typeof value === "boolean") return `boolean:${value}`;
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	throw new Error("Resource source objects require an explicit options.key");
+};
+/**
+* Creates a single-owner async resource. Every request has a generation and
+* AbortSignal, so a late response cannot overwrite a newer result.
+*/
+function createResource(source, fetcher, options = {}) {
+	var _options$key;
+	const keyOf = (_options$key = options.key) !== null && _options$key !== void 0 ? _options$key : primitiveKey;
+	const cache = /* @__PURE__ */ new Map();
+	const [state, setState] = createSignal({
+		status: "pending",
+		pending: true,
+		success: false,
+		error: void 0,
+		data: options.initialData,
+		stale: options.initialData !== void 0,
+		updatedAt: void 0
+	});
+	let controller;
+	let generation = 0;
+	let disposed = false;
+	let lastSource;
+	const cancel = () => {
+		generation++;
+		controller === null || controller === void 0 || controller.abort();
+		controller = void 0;
+	};
+	const refetch = function() {
+		var _ref = _asyncToGenerator(function* () {
+			if (disposed) throw new Error("Resource has been disposed");
+			const currentSource = lastSource;
+			const key = keyOf(currentSource);
+			const now = Date.now();
+			cancel();
+			const requestGeneration = ++generation;
+			const cached = cache.get(key);
+			if (cached && options.staleTime !== void 0 && now - cached.updatedAt < options.staleTime) {
+				setState({
+					status: "success",
+					pending: false,
+					success: true,
+					error: void 0,
+					data: cached.data,
+					stale: false,
+					updatedAt: cached.updatedAt
+				});
+				return cached.data;
+			}
+			const requestController = new AbortController();
+			controller = requestController;
+			const previous = state().data;
+			setState({
+				status: "pending",
+				pending: true,
+				success: false,
+				error: void 0,
+				data: previous,
+				stale: previous !== void 0,
+				updatedAt: state().updatedAt
+			});
+			try {
+				const data = yield fetcher(currentSource, { signal: requestController.signal });
+				if (disposed || requestGeneration !== generation) throw new Error("Resource request became stale");
+				const updatedAt = Date.now();
+				cache.set(key, {
+					data,
+					updatedAt
+				});
+				setState({
+					status: "success",
+					pending: false,
+					success: true,
+					error: void 0,
+					data,
+					stale: false,
+					updatedAt
+				});
+				return data;
+			} catch (error) {
+				if (disposed || requestGeneration !== generation) throw error;
+				if (requestController.signal.aborted) setState(_objectSpread2(_objectSpread2({}, state()), {}, {
+					status: "pending",
+					pending: true,
+					success: false,
+					stale: state().data !== void 0
+				}));
+				else setState(_objectSpread2(_objectSpread2({}, state()), {}, {
+					status: "error",
+					pending: false,
+					success: false,
+					error,
+					stale: state().data !== void 0
+				}));
+				throw error;
+			} finally {
+				if (controller === requestController) controller = void 0;
+			}
+		});
+		return function refetch() {
+			return _ref.apply(this, arguments);
+		};
+	}();
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		cancel();
+		cache.clear();
+	};
+	const readSource = () => typeof source === "function" ? source() : source;
+	const load = () => {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	};
+	if (typeof source === "function" && getCurrentScope()) createEffect(load);
+	else {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	}
+	if (getCurrentScope()) onCleanup(dispose);
+	return {
+		state,
+		status: () => state().status,
+		pending: () => state().pending,
+		success: () => state().success,
+		error: () => state().error,
+		data: () => state().data,
+		stale: () => state().stale,
+		updatedAt: () => state().updatedAt,
+		refetch,
+		cancel,
+		dispose
+	};
+}
+//#endregion
+export { createResource };

package/dist/resource.prod.cjs

@@ -0,0 +1,151 @@
+/**
+* resource v0.1.1-beta.14
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _zeus_js_signal = require("@zeus-js/signal");
+let _zeus_js_signal_internal = require("@zeus-js/signal/internal");
+//#region packages/core/resource/src/index.ts
+const primitiveKey = (value) => {
+	if (typeof value === "string") return `string:${value}`;
+	if (typeof value === "number") return `number:${value}`;
+	if (typeof value === "boolean") return `boolean:${value}`;
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	throw new Error("Resource source objects require an explicit options.key");
+};
+/**
+* Creates a single-owner async resource. Every request has a generation and
+* AbortSignal, so a late response cannot overwrite a newer result.
+*/
+function createResource(source, fetcher, options = {}) {
+	var _options$key;
+	const keyOf = (_options$key = options.key) !== null && _options$key !== void 0 ? _options$key : primitiveKey;
+	const cache = /* @__PURE__ */ new Map();
+	const [state, setState] = (0, _zeus_js_signal.createSignal)({
+		status: "pending",
+		pending: true,
+		success: false,
+		error: void 0,
+		data: options.initialData,
+		stale: options.initialData !== void 0,
+		updatedAt: void 0
+	});
+	let controller;
+	let generation = 0;
+	let disposed = false;
+	let lastSource;
+	const cancel = () => {
+		generation++;
+		controller === null || controller === void 0 || controller.abort();
+		controller = void 0;
+	};
+	const refetch = async () => {
+		if (disposed) throw new Error("Resource has been disposed");
+		const currentSource = lastSource;
+		const key = keyOf(currentSource);
+		const now = Date.now();
+		cancel();
+		const requestGeneration = ++generation;
+		const cached = cache.get(key);
+		if (cached && options.staleTime !== void 0 && now - cached.updatedAt < options.staleTime) {
+			setState({
+				status: "success",
+				pending: false,
+				success: true,
+				error: void 0,
+				data: cached.data,
+				stale: false,
+				updatedAt: cached.updatedAt
+			});
+			return cached.data;
+		}
+		const requestController = new AbortController();
+		controller = requestController;
+		const previous = state().data;
+		setState({
+			status: "pending",
+			pending: true,
+			success: false,
+			error: void 0,
+			data: previous,
+			stale: previous !== void 0,
+			updatedAt: state().updatedAt
+		});
+		try {
+			const data = await fetcher(currentSource, { signal: requestController.signal });
+			if (disposed || requestGeneration !== generation) throw new Error("Resource request became stale");
+			const updatedAt = Date.now();
+			cache.set(key, {
+				data,
+				updatedAt
+			});
+			setState({
+				status: "success",
+				pending: false,
+				success: true,
+				error: void 0,
+				data,
+				stale: false,
+				updatedAt
+			});
+			return data;
+		} catch (error) {
+			if (disposed || requestGeneration !== generation) throw error;
+			if (requestController.signal.aborted) setState({
+				...state(),
+				status: "pending",
+				pending: true,
+				success: false,
+				stale: state().data !== void 0
+			});
+			else setState({
+				...state(),
+				status: "error",
+				pending: false,
+				success: false,
+				error,
+				stale: state().data !== void 0
+			});
+			throw error;
+		} finally {
+			if (controller === requestController) controller = void 0;
+		}
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		cancel();
+		cache.clear();
+	};
+	const readSource = () => typeof source === "function" ? source() : source;
+	const load = () => {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	};
+	if (typeof source === "function" && (0, _zeus_js_signal_internal.getCurrentScope)()) (0, _zeus_js_signal.createEffect)(load);
+	else {
+		lastSource = readSource();
+		refetch().catch(() => void 0);
+	}
+	if ((0, _zeus_js_signal_internal.getCurrentScope)()) (0, _zeus_js_signal.onCleanup)(dispose);
+	return {
+		state,
+		status: () => state().status,
+		pending: () => state().pending,
+		success: () => state().success,
+		error: () => state().error,
+		data: () => state().data,
+		stale: () => state().stale,
+		updatedAt: () => state().updatedAt,
+		refetch,
+		cancel,
+		dispose
+	};
+}
+//#endregion
+exports.createResource = createResource;

package/index.cjs

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/resource.prod.cjs')
+} else {
+  module.exports = require('./dist/resource.cjs')
+}

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@zeus-js/resource",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.1.1-beta.14",
+  "description": "Fine-grained async resource primitives for Zeus",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baicie/zeus.git",
+    "directory": "packages/core/resource"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/resource.d.ts",
+      "module": "./dist/resource.esm-bundler.js",
+      "import": "./dist/resource.esm-bundler.js",
+      "require": {
+        "production": "./dist/resource.prod.cjs",
+        "development": "./dist/resource.cjs",
+        "default": "./index.cjs"
+      }
+    }
+  },
+  "files": [
+    "index.cjs",
+    "dist"
+  ],
+  "dependencies": {
+    "@zeus-js/signal": "0.1.1-beta.14"
+  },
+  "buildOptions": {
+    "name": "ZeusResource",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "main": "index.cjs",
+  "module": "dist/resource.esm-bundler.js",
+  "types": "dist/resource.d.ts"
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.