eclipsa 0.1.0 → 0.2.0-alpha.0

package/snapshot-BbvDaNMJ.mjs

@@ -0,0 +1,139 @@
+import { A as getRuntimeContainer, C as createOnCleanup, D as createStandaloneRuntimeSignal, I as readAsyncSignalSnapshot, J as writeAsyncSignalSnapshot, K as useRuntimeSignal, Nt as createPendingSignalError, O as createWatch, Pt as isPendingSignalError, S as createEffect, T as createOnVisible, j as getRuntimeSignalId, w as createOnMount } from "./action-LXy_7T1f.mjs";
+//#region core/signal.ts
+const isPromiseLike = (value) => !!value && typeof value === "object" && "then" in value && typeof value.then === "function";
+const isComputedSnapshot = (value) => !!value && typeof value === "object" && value.__e_async_computed === true;
+const createComputedSnapshot = (snapshot) => ({
+	__e_async_computed: true,
+	...snapshot
+});
+const createComputedSignalFactory = (createBaseSignal) => (fn) => {
+	const state = createBaseSignal(createComputedSnapshot({ status: "pending" }));
+	const runtimeContainer = getRuntimeContainer();
+	const signalId = getRuntimeSignalId(state);
+	const seededSnapshot = signalId !== null ? readAsyncSignalSnapshot(signalId, runtimeContainer) : void 0;
+	let useSeededSnapshot = !!seededSnapshot && seededSnapshot.status !== "pending";
+	let version = 0;
+	effect(() => {
+		if (useSeededSnapshot && seededSnapshot) {
+			useSeededSnapshot = false;
+			state.value = seededSnapshot;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, seededSnapshot, runtimeContainer);
+			return;
+		}
+		const currentVersion = ++version;
+		try {
+			const nextValue = fn();
+			if (isPromiseLike(nextValue)) {
+				const pending = createComputedSnapshot({
+					promise: nextValue,
+					status: "pending"
+				});
+				state.value = pending;
+				if (signalId !== null) writeAsyncSignalSnapshot(signalId, pending, runtimeContainer);
+				nextValue.then((resolved) => {
+					if (currentVersion !== version) return;
+					const completed = createComputedSnapshot({
+						status: "resolved",
+						value: resolved
+					});
+					state.value = completed;
+					if (signalId !== null) writeAsyncSignalSnapshot(signalId, completed, runtimeContainer);
+				}, (error) => {
+					if (currentVersion !== version) return;
+					const failed = createComputedSnapshot({
+						error,
+						status: "rejected"
+					});
+					state.value = failed;
+					if (signalId !== null) writeAsyncSignalSnapshot(signalId, failed, runtimeContainer);
+				});
+				return;
+			}
+			const resolved = createComputedSnapshot({
+				status: "resolved",
+				value: nextValue
+			});
+			state.value = resolved;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, resolved, runtimeContainer);
+		} catch (error) {
+			if (isPendingSignalError(error)) {
+				const pending = createComputedSnapshot({
+					promise: error.promise,
+					status: "pending"
+				});
+				state.value = pending;
+				if (signalId !== null) writeAsyncSignalSnapshot(signalId, pending, runtimeContainer);
+				return;
+			}
+			const failed = createComputedSnapshot({
+				error,
+				status: "rejected"
+			});
+			state.value = failed;
+			if (signalId !== null) writeAsyncSignalSnapshot(signalId, failed, runtimeContainer);
+		}
+	});
+	const handle = {};
+	Object.defineProperty(handle, "value", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const snapshot = state.value;
+			if (!isComputedSnapshot(snapshot)) return snapshot;
+			if (snapshot.status === "pending") throw createPendingSignalError(snapshot.promise ?? Promise.resolve(void 0));
+			if (snapshot.status === "rejected") throw snapshot.error;
+			return snapshot.value;
+		}
+	});
+	return handle;
+};
+const signal = ((value) => createStandaloneRuntimeSignal(value));
+const useSignal = ((value) => useRuntimeSignal(value));
+signal.computed = createComputedSignalFactory((value) => createStandaloneRuntimeSignal(value));
+useSignal.computed = createComputedSignalFactory((value) => useRuntimeSignal(value));
+const effect = (fn) => createEffect(fn);
+const onCleanup = (fn) => createOnCleanup(fn);
+const onMount = (fn) => createOnMount(fn);
+const onVisible = (fn) => createOnVisible(fn);
+const useWatch = (fn, dependencies) => createWatch(fn, dependencies);
+const useComputed$ = (fn) => useSignal.computed(fn);
+//#endregion
+//#region core/snapshot.ts
+const SNAPSHOT_STATE_KEY = Symbol.for("eclipsa.snapshot-state");
+const getCurrentSnapshotState = () => {
+	return globalThis[SNAPSHOT_STATE_KEY] ?? null;
+};
+const setCurrentSnapshotState = (state) => {
+	globalThis[SNAPSHOT_STATE_KEY] = state;
+};
+const withSignalSnapshot = (values, fn) => {
+	const previous = getCurrentSnapshotState();
+	const state = {
+		readers: [],
+		cursor: 0,
+		values
+	};
+	setCurrentSnapshotState(state);
+	try {
+		return {
+			result: fn(),
+			values: values ?? state.readers.map((reader) => reader.read())
+		};
+	} finally {
+		setCurrentSnapshotState(previous);
+	}
+};
+const consumeSnapshotValue = (fallback) => {
+	const state = getCurrentSnapshotState();
+	if (!state) return fallback;
+	const index = state.cursor++;
+	if (state.values && index < state.values.length) return state.values[index];
+	return fallback;
+};
+const registerSnapshotSignal = (reader) => {
+	getCurrentSnapshotState()?.readers.push(reader);
+};
+//#endregion
+export { onCleanup as a, signal as c, useWatch as d, effect as i, useComputed$ as l, registerSnapshotSignal as n, onMount as o, withSignalSnapshot as r, onVisible as s, consumeSnapshotValue as t, useSignal as u };
+
+//# sourceMappingURL=snapshot-BbvDaNMJ.mjs.map

package/snapshot-BbvDaNMJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-BbvDaNMJ.mjs","names":[],"sources":["../core/signal.ts","../core/snapshot.ts"],"sourcesContent":["import {\n  createStandaloneRuntimeSignal,\n  createEffect,\n  createOnCleanup,\n  createOnMount,\n  createOnVisible,\n  createWatch,\n  getRuntimeContainer,\n  getRuntimeSignalId,\n  readAsyncSignalSnapshot,\n  useRuntimeSignal,\n  writeAsyncSignalSnapshot,\n} from './runtime.ts'\nimport { createPendingSignalError, isPendingSignalError } from './suspense.ts'\n\nexport interface Signal<T> {\n  value: T\n}\n\ninterface SignalFactory {\n  <T>(value: T): Signal<T>\n  <T>(value?: T | undefined): Signal<T | undefined>\n  computed<T>(value: () => T | Promise<T>): Signal<T>\n}\n\ninterface ComputedSnapshot<T> {\n  __e_async_computed: true\n  error?: unknown\n  promise?: Promise<T>\n  status: 'pending' | 'rejected' | 'resolved'\n  value?: T\n}\n\nexport type WatchDependency<T = unknown> = Signal<T> | (() => T)\n\nconst isPromiseLike = <T>(value: unknown): value is Promise<T> =>\n  !!value && typeof value === 'object' && 'then' in value && typeof value.then === 'function'\n\nconst isComputedSnapshot = <T>(value: unknown): value is ComputedSnapshot<T> =>\n  !!value && typeof value === 'object' && (value as ComputedSnapshot<T>).__e_async_computed === true\n\nconst createComputedSnapshot = <T>(\n  snapshot: Omit<ComputedSnapshot<T>, '__e_async_computed'>,\n): ComputedSnapshot<T> => ({\n  __e_async_computed: true,\n  ...snapshot,\n})\n\nconst createComputedSignalFactory =\n  (createBaseSignal: <T>(value: T) => Signal<T>): SignalFactory['computed'] =>\n  <T>(fn: () => T | Promise<T>) => {\n    const state = createBaseSignal<ComputedSnapshot<T>>(\n      createComputedSnapshot({\n        status: 'pending',\n      }),\n    )\n    const runtimeContainer = getRuntimeContainer()\n    const signalId = getRuntimeSignalId(state)\n    const seededSnapshot =\n      signalId !== null\n        ? (readAsyncSignalSnapshot(signalId, runtimeContainer) as ComputedSnapshot<T> | undefined)\n        : undefined\n    let useSeededSnapshot = !!seededSnapshot && seededSnapshot.status !== 'pending'\n    let version = 0\n\n    effect(() => {\n      if (useSeededSnapshot && seededSnapshot) {\n        useSeededSnapshot = false\n        state.value = seededSnapshot\n        if (signalId !== null) {\n          writeAsyncSignalSnapshot(signalId, seededSnapshot, runtimeContainer)\n        }\n        return\n      }\n\n      const currentVersion = ++version\n      try {\n        const nextValue = fn()\n        if (isPromiseLike<T>(nextValue)) {\n          const pending = createComputedSnapshot<T>({\n            promise: nextValue,\n            status: 'pending',\n          })\n          state.value = pending\n          if (signalId !== null) {\n            writeAsyncSignalSnapshot(signalId, pending, runtimeContainer)\n          }\n          nextValue.then(\n            (resolved) => {\n              if (currentVersion !== version) {\n                return\n              }\n              const completed = createComputedSnapshot<T>({\n                status: 'resolved',\n                value: resolved,\n              })\n              state.value = completed\n              if (signalId !== null) {\n                writeAsyncSignalSnapshot(signalId, completed, runtimeContainer)\n              }\n            },\n            (error) => {\n              if (currentVersion !== version) {\n                return\n              }\n              const failed = createComputedSnapshot<T>({\n                error,\n                status: 'rejected',\n              })\n              state.value = failed\n              if (signalId !== null) {\n                writeAsyncSignalSnapshot(signalId, failed, runtimeContainer)\n              }\n            },\n          )\n          return\n        }\n\n        const resolved = createComputedSnapshot<T>({\n          status: 'resolved',\n          value: nextValue,\n        })\n        state.value = resolved\n        if (signalId !== null) {\n          writeAsyncSignalSnapshot(signalId, resolved, runtimeContainer)\n        }\n      } catch (error) {\n        if (isPendingSignalError(error)) {\n          const pending = createComputedSnapshot<T>({\n            promise: error.promise as Promise<T>,\n            status: 'pending',\n          })\n          state.value = pending\n          if (signalId !== null) {\n            writeAsyncSignalSnapshot(signalId, pending, runtimeContainer)\n          }\n          return\n        }\n        const failed = createComputedSnapshot<T>({\n          error,\n          status: 'rejected',\n        })\n        state.value = failed\n        if (signalId !== null) {\n          writeAsyncSignalSnapshot(signalId, failed, runtimeContainer)\n        }\n      }\n    })\n\n    const handle = {} as Signal<T>\n    Object.defineProperty(handle, 'value', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        const snapshot = state.value\n        if (!isComputedSnapshot<T>(snapshot)) {\n          return snapshot as T\n        }\n        if (snapshot.status === 'pending') {\n          throw createPendingSignalError(snapshot.promise ?? Promise.resolve(undefined))\n        }\n        if (snapshot.status === 'rejected') {\n          throw snapshot.error\n        }\n        return snapshot.value as T\n      },\n    })\n    return handle\n  }\n\nexport const signal = ((value) => createStandaloneRuntimeSignal(value)) as SignalFactory\n\nexport const useSignal = ((value) => useRuntimeSignal(value)) as SignalFactory\n\nsignal.computed = createComputedSignalFactory((value) => createStandaloneRuntimeSignal(value))\nuseSignal.computed = createComputedSignalFactory((value) => useRuntimeSignal(value))\n\nexport const effect = (fn: () => void) => createEffect(fn)\nexport const onCleanup = (fn: () => void) => createOnCleanup(fn)\nexport const onMount = (fn: () => void) => createOnMount(fn)\nexport const onVisible = (fn: () => void) => createOnVisible(fn)\nexport const useWatch = (fn: () => void, dependencies?: WatchDependency[]) =>\n  createWatch(fn, dependencies)\n\nexport const useComputed$ = <T>(fn: () => T | Promise<T>) => useSignal.computed(fn)\n","interface SignalReader {\n  read(): unknown\n}\n\ninterface SnapshotState {\n  readers: SignalReader[]\n  cursor: number\n  values: unknown[] | null\n}\n\nconst SNAPSHOT_STATE_KEY = Symbol.for('eclipsa.snapshot-state')\n\nconst getCurrentSnapshotState = (): SnapshotState | null => {\n  return (\n    (globalThis as unknown as Record<PropertyKey, SnapshotState | null>)[SNAPSHOT_STATE_KEY] ?? null\n  )\n}\n\nconst setCurrentSnapshotState = (state: SnapshotState | null) => {\n  ;(globalThis as unknown as Record<PropertyKey, SnapshotState | null>)[SNAPSHOT_STATE_KEY] = state\n}\n\nexport const withSignalSnapshot = <T>(\n  values: unknown[] | null,\n  fn: () => T,\n): {\n  result: T\n  values: unknown[]\n} => {\n  const previous = getCurrentSnapshotState()\n  const state: SnapshotState = {\n    readers: [],\n    cursor: 0,\n    values,\n  }\n  setCurrentSnapshotState(state)\n\n  try {\n    const result = fn()\n    return {\n      result,\n      values: values ?? state.readers.map((reader) => reader.read()),\n    }\n  } finally {\n    setCurrentSnapshotState(previous)\n  }\n}\n\nexport const consumeSnapshotValue = <T>(fallback: T): T => {\n  const state = getCurrentSnapshotState()\n  if (!state) {\n    return fallback\n  }\n\n  const index = state.cursor++\n  if (state.values && index < state.values.length) {\n    return state.values[index] as T\n  }\n\n  return fallback\n}\n\nexport const registerSnapshotSignal = (reader: SignalReader) => {\n  getCurrentSnapshotState()?.readers.push(reader)\n}\n"],"mappings":"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"}

package/types-DFdkOqSj.d.mts

@@ -0,0 +1,35 @@
+//#region jsx/types.d.ts
+declare namespace JSX {
+  interface SSRTemplate {
+    __e_ssr_template: true;
+    strings: readonly string[];
+    values: readonly unknown[];
+  }
+  type Type = string | ((props: unknown) => Element);
+  type Childable = Element;
+  type Element = {
+    type: Type;
+    props: Record<string, unknown>;
+    key?: string | number | symbol | null;
+    isStatic: boolean;
+    metadata?: Metadata;
+  } | SSRTemplate | string | number | undefined | null | boolean | ((() => Element) & {
+    key?: string | number | symbol;
+  });
+  interface Metadata {
+    componentID?: number;
+    fileid?: string;
+  }
+  interface IntrinsicAttributes {
+    key?: any;
+  }
+  interface IntrinsicElements {
+    [name: string]: any;
+  }
+  interface ElementChildrenAttribute {
+    children?: any;
+  }
+}
+//#endregion
+export { JSX as t };
+//# sourceMappingURL=types-DFdkOqSj.d.mts.map

package/vite/mod.d.mts

@@ -0,0 +1,13 @@
+import { PluginOption } from "vite";
+
+//#region vite/options.d.ts
+type EclipsaOutputTarget = 'node' | 'ssg';
+interface EclipsaPluginOptions {
+  output?: EclipsaOutputTarget;
+}
+//#endregion
+//#region vite/mod.d.ts
+declare const eclipsa: (options?: EclipsaPluginOptions) => PluginOption;
+//#endregion
+export { type EclipsaPluginOptions, eclipsa };
+//# sourceMappingURL=mod.d.mts.map