release: WRNexusJS 0.6.0
This commit is contained in:
@@ -0,0 +1,511 @@
|
||||
import type {
|
||||
StoreActionContext,
|
||||
StoreDefinition,
|
||||
StoreInstance,
|
||||
StoreInstanceCore,
|
||||
StoreMutation,
|
||||
StorePersistenceConfig,
|
||||
StoreCombinedState,
|
||||
StoreFunction,
|
||||
} from "./types.ts";
|
||||
export type * from "./types.ts";
|
||||
|
||||
const memoryPersistence = new Map<string, string>();
|
||||
|
||||
function clone<T>(value: T): T {
|
||||
if (typeof structuredClone === "function") {
|
||||
try {
|
||||
return structuredClone(value);
|
||||
} catch {
|
||||
/* Proxies are cloned through their JSON-visible state below. */
|
||||
}
|
||||
}
|
||||
return JSON.parse(JSON.stringify(value)) as T;
|
||||
}
|
||||
|
||||
function readonlySnapshot<S extends object>(state: S): Readonly<S> {
|
||||
return Object.freeze(clone(state));
|
||||
}
|
||||
|
||||
function storageFor(kind: StorePersistenceConfig<any>["storage"]): Storage | null {
|
||||
if (typeof window === "undefined") return null;
|
||||
if (kind === "local") return window.localStorage;
|
||||
if (kind === "session") return window.sessionStorage;
|
||||
return null;
|
||||
}
|
||||
|
||||
function readPersisted<S extends object>(
|
||||
key: string,
|
||||
config: StorePersistenceConfig<S>,
|
||||
): Partial<S> | null {
|
||||
try {
|
||||
const raw =
|
||||
config.storage === "memory"
|
||||
? memoryPersistence.get(key)
|
||||
: storageFor(config.storage)?.getItem(key);
|
||||
if (!raw) return null;
|
||||
const parsed = JSON.parse(raw) as { version?: number; state?: unknown };
|
||||
const from = Number(parsed.version ?? 0);
|
||||
let state = parsed.state;
|
||||
if (from !== config.version && config.migrate)
|
||||
state = config.migrate(state, from, config.version);
|
||||
if (config.validate) return config.validate(state);
|
||||
if (!state || typeof state !== "object" || Array.isArray(state)) return null;
|
||||
return state as Partial<S>;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function writePersisted<S extends object>(
|
||||
key: string,
|
||||
state: S,
|
||||
config: StorePersistenceConfig<S>,
|
||||
): void {
|
||||
const picked: Record<string, unknown> = {};
|
||||
for (const name of config.include) picked[name] = state[name];
|
||||
const raw = JSON.stringify({ version: config.version, state: picked });
|
||||
if (config.storage === "memory") memoryPersistence.set(key, raw);
|
||||
else storageFor(config.storage)?.setItem(key, raw);
|
||||
}
|
||||
|
||||
export function defineStore<
|
||||
S extends object,
|
||||
C extends object = Record<string, never>,
|
||||
A extends Record<string, StoreFunction> = Record<string, StoreFunction>,
|
||||
CS extends object = Record<string, never>,
|
||||
SS extends object = Record<string, never>,
|
||||
>(definition: StoreDefinition<S, C, A, CS, SS>): StoreDefinition<S, C, A, CS, SS> {
|
||||
return definition;
|
||||
}
|
||||
|
||||
export interface StoreContainerOptions {
|
||||
runtime: "server" | "client";
|
||||
request?: unknown;
|
||||
routeId?: string;
|
||||
hydration?: Record<string, unknown>;
|
||||
onMutation?: (mutation: StoreMutation) => void;
|
||||
}
|
||||
|
||||
export class StoreContainer {
|
||||
readonly runtime: "server" | "client";
|
||||
readonly request?: unknown;
|
||||
readonly routeId?: string;
|
||||
private readonly instances = new Map<string, StoreInstance<any, any, any>>();
|
||||
private readonly hydration: Record<string, unknown>;
|
||||
private readonly onMutation?: (mutation: StoreMutation) => void;
|
||||
private readonly lastMutations = new Map<string, StoreMutation>();
|
||||
|
||||
constructor(options: StoreContainerOptions) {
|
||||
this.runtime = options.runtime;
|
||||
this.request = options.request;
|
||||
this.routeId = options.routeId;
|
||||
this.hydration = options.hydration ?? {};
|
||||
this.onMutation = options.onMutation;
|
||||
}
|
||||
|
||||
async use<
|
||||
S extends object,
|
||||
C extends object,
|
||||
A extends Record<string, StoreFunction>,
|
||||
CS extends object,
|
||||
SS extends object,
|
||||
>(
|
||||
definition: StoreDefinition<S, C, A, CS, SS>,
|
||||
): Promise<StoreInstance<StoreCombinedState<S, CS, SS>, C, A>> {
|
||||
const key =
|
||||
definition.kind === "page"
|
||||
? `${definition.name}@${this.routeId ?? "default"}`
|
||||
: definition.name;
|
||||
const existing = this.instances.get(key);
|
||||
if (existing) return existing as StoreInstance<StoreCombinedState<S, CS, SS>, C, A>;
|
||||
const instance = createStoreInstance(definition, {
|
||||
runtime: this.runtime,
|
||||
request: this.request,
|
||||
routeId: this.routeId,
|
||||
hydration: this.hydration[definition.name],
|
||||
onMutation: (mutation) => {
|
||||
this.lastMutations.set(definition.name, mutation);
|
||||
this.onMutation?.(mutation);
|
||||
},
|
||||
});
|
||||
this.instances.set(key, instance);
|
||||
await instance.whenReady;
|
||||
return instance;
|
||||
}
|
||||
|
||||
serialize(): Record<string, unknown> {
|
||||
return Object.fromEntries(
|
||||
Array.from(this.instances.values(), (instance) => [instance.name, instance.serialize()]),
|
||||
);
|
||||
}
|
||||
|
||||
inspect(): Array<{
|
||||
name: string;
|
||||
kind: "global" | "page";
|
||||
state: Readonly<Record<string, unknown>>;
|
||||
computed: Readonly<Record<string, unknown>>;
|
||||
lastAction?: string;
|
||||
changed: string[];
|
||||
hydrationSource: "server" | "persistence" | "initial";
|
||||
}> {
|
||||
return Array.from(this.instances.values(), (instance) => {
|
||||
const mutation = this.lastMutations.get(instance.name);
|
||||
return {
|
||||
name: instance.name,
|
||||
kind: instance.kind,
|
||||
state: instance.snapshot() as Readonly<Record<string, unknown>>,
|
||||
computed: Object.freeze(
|
||||
Object.fromEntries(
|
||||
Reflect.ownKeys(instance.computed).map((key) => [
|
||||
String(key),
|
||||
(instance.computed as any)[key],
|
||||
]),
|
||||
),
|
||||
),
|
||||
...(mutation ? { lastAction: mutation.action } : {}),
|
||||
changed: mutation?.changed ?? [],
|
||||
hydrationSource: this.hydration[instance.name] ? "server" : "initial",
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
async hotUpdate<
|
||||
S extends object,
|
||||
C extends object,
|
||||
A extends Record<string, StoreFunction>,
|
||||
CS extends object,
|
||||
SS extends object,
|
||||
>(
|
||||
definition: StoreDefinition<S, C, A, CS, SS>,
|
||||
): Promise<{ preserved: string[]; reset: string[] }> {
|
||||
const entries = [...this.instances.entries()].filter(
|
||||
([, instance]) => instance.name === definition.name,
|
||||
);
|
||||
const preserved = new Set<string>();
|
||||
const reset = new Set<string>();
|
||||
for (const [key, previous] of entries) {
|
||||
const snapshot = previous.snapshot() as Record<string, unknown>;
|
||||
await previous.dispose();
|
||||
const freshShared = definition.createSharedState();
|
||||
const freshRuntime =
|
||||
this.runtime === "client"
|
||||
? (definition.createClientState?.() ?? {})
|
||||
: (definition.createServerState?.() ?? {});
|
||||
const nextShape = { ...freshShared, ...freshRuntime } as Record<string, unknown>;
|
||||
const compatible: Record<string, unknown> = {};
|
||||
for (const [name, value] of Object.entries(snapshot)) {
|
||||
if (!(name in nextShape)) continue;
|
||||
const expected = nextShape[name];
|
||||
const same =
|
||||
expected === null || value === null
|
||||
? expected === value || expected === null
|
||||
: Array.isArray(expected)
|
||||
? Array.isArray(value)
|
||||
: typeof expected === typeof value;
|
||||
if (same) {
|
||||
compatible[name] = value;
|
||||
preserved.add(name);
|
||||
} else reset.add(name);
|
||||
}
|
||||
for (const name of Object.keys(nextShape))
|
||||
if (!(name in compatible) && name in snapshot) reset.add(name);
|
||||
const instance = createStoreInstance(definition, {
|
||||
runtime: this.runtime,
|
||||
request: this.request,
|
||||
routeId: this.routeId,
|
||||
hydration: compatible,
|
||||
onMutation: (mutation) => {
|
||||
this.lastMutations.set(definition.name, mutation);
|
||||
this.onMutation?.(mutation);
|
||||
},
|
||||
});
|
||||
this.instances.set(key, instance);
|
||||
await instance.whenReady;
|
||||
}
|
||||
return { preserved: [...preserved], reset: [...reset] };
|
||||
}
|
||||
|
||||
async disposePageStores(): Promise<void> {
|
||||
for (const [key, instance] of [...this.instances]) {
|
||||
if (instance.kind !== "page") continue;
|
||||
await instance.dispose();
|
||||
this.instances.delete(key);
|
||||
}
|
||||
}
|
||||
|
||||
async dispose(): Promise<void> {
|
||||
for (const instance of this.instances.values()) await instance.dispose();
|
||||
this.instances.clear();
|
||||
}
|
||||
}
|
||||
|
||||
export function createStoreContainer(options: StoreContainerOptions): StoreContainer {
|
||||
return new StoreContainer(options);
|
||||
}
|
||||
|
||||
export function createStoreInstance<
|
||||
S extends object,
|
||||
C extends object,
|
||||
A extends Record<string, StoreFunction>,
|
||||
CS extends object,
|
||||
SS extends object,
|
||||
>(
|
||||
definition: StoreDefinition<S, C, A, CS, SS>,
|
||||
options: Omit<StoreContainerOptions, "hydration"> & { hydration?: unknown },
|
||||
): StoreInstance<StoreCombinedState<S, CS, SS>, C, A> {
|
||||
type State = StoreCombinedState<S, CS, SS>;
|
||||
const createInitialState = (): State =>
|
||||
({
|
||||
...definition.createSharedState(),
|
||||
...(options.runtime === "client"
|
||||
? definition.createClientState?.()
|
||||
: definition.createServerState?.()),
|
||||
}) as State;
|
||||
const initial = createInitialState();
|
||||
const persisted =
|
||||
options.runtime === "client" && definition.persist
|
||||
? readPersisted(`wrnexus:store:${definition.name}`, definition.persist)
|
||||
: null;
|
||||
const hydrated =
|
||||
options.hydration && typeof options.hydration === "object"
|
||||
? (options.hydration as Partial<State>)
|
||||
: null;
|
||||
const raw = Object.assign(initial, persisted ?? {}, hydrated ?? {});
|
||||
const listeners = new Set<(snapshot: Readonly<State>, mutation?: StoreMutation) => void>();
|
||||
let currentAction = "direct";
|
||||
let internalMutation = false;
|
||||
|
||||
const mutableState = new Proxy(raw, {
|
||||
set(target, property, value) {
|
||||
if (!internalMutation) {
|
||||
throw new TypeError(
|
||||
`WRN-STORE-READONLY: ${definition.name}.${String(property)} must be changed by a store action.`,
|
||||
);
|
||||
}
|
||||
if (Object.is(Reflect.get(target, property), value)) return true;
|
||||
const before = readonlySnapshot(target);
|
||||
Reflect.set(target, property, value);
|
||||
const after = readonlySnapshot(target);
|
||||
const mutation: StoreMutation = {
|
||||
store: definition.name,
|
||||
action: currentAction,
|
||||
changed: [String(property)],
|
||||
before: before as Readonly<Record<string, unknown>>,
|
||||
after: after as Readonly<Record<string, unknown>>,
|
||||
timestamp: Date.now(),
|
||||
};
|
||||
if (definition.persist && options.runtime === "client") {
|
||||
writePersisted(`wrnexus:store:${definition.name}`, target, definition.persist);
|
||||
}
|
||||
options.onMutation?.(mutation);
|
||||
for (const listener of listeners) listener(after, mutation);
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, property) {
|
||||
if (!internalMutation) {
|
||||
throw new TypeError(
|
||||
`WRN-STORE-READONLY: ${definition.name}.${String(property)} must be changed by a store action.`,
|
||||
);
|
||||
}
|
||||
return Reflect.deleteProperty(target, property);
|
||||
},
|
||||
});
|
||||
|
||||
const publicState = new Proxy({} as State, {
|
||||
get(_target, property) {
|
||||
return (mutableState as any)[property];
|
||||
},
|
||||
set(_target, property) {
|
||||
throw new TypeError(
|
||||
`WRN-STORE-READONLY: ${definition.name}.${String(property)} must be changed by a store action.`,
|
||||
);
|
||||
},
|
||||
deleteProperty(_target, property) {
|
||||
throw new TypeError(
|
||||
`WRN-STORE-READONLY: ${definition.name}.${String(property)} must be changed by a store action.`,
|
||||
);
|
||||
},
|
||||
ownKeys() {
|
||||
return Reflect.ownKeys(mutableState);
|
||||
},
|
||||
getOwnPropertyDescriptor(_target, property) {
|
||||
if (!(property in mutableState)) return undefined;
|
||||
return {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
value: (mutableState as any)[property],
|
||||
writable: false,
|
||||
};
|
||||
},
|
||||
has(_target, property) {
|
||||
return property in mutableState;
|
||||
},
|
||||
});
|
||||
|
||||
const mutate = <T>(action: string, callback: () => T): T => {
|
||||
const previousAction = currentAction;
|
||||
const previousMutation = internalMutation;
|
||||
currentAction = action;
|
||||
internalMutation = true;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentAction = previousAction;
|
||||
internalMutation = previousMutation;
|
||||
}
|
||||
};
|
||||
|
||||
const reset = () =>
|
||||
mutate("$reset", () => {
|
||||
const next = createInitialState();
|
||||
for (const key of Object.keys(mutableState)) {
|
||||
if (!(key in next)) delete (mutableState as any)[key];
|
||||
}
|
||||
Object.assign(mutableState, next);
|
||||
});
|
||||
|
||||
const context: StoreActionContext<State> = {
|
||||
state: mutableState,
|
||||
snapshot: () => readonlySnapshot(mutableState),
|
||||
reset,
|
||||
runtime: options.runtime,
|
||||
request: options.request,
|
||||
routeId: options.routeId,
|
||||
};
|
||||
|
||||
const actions = {} as A;
|
||||
for (const [name, rawDefinitions] of Object.entries(definition.actions ?? {})) {
|
||||
const definitions = Array.isArray(rawDefinitions) ? rawDefinitions : [rawDefinitions];
|
||||
const selected =
|
||||
definitions.find((entry) => entry.runtime === options.runtime) ??
|
||||
definitions.find((entry) => entry.runtime === "shared") ??
|
||||
definitions.find((entry) => entry.runtime === "legacy");
|
||||
if (!selected) continue;
|
||||
(actions as any)[name] = async (...args: unknown[]) => {
|
||||
currentAction = name;
|
||||
internalMutation = true;
|
||||
try {
|
||||
return await (selected.handler as any)(context, ...args);
|
||||
} finally {
|
||||
currentAction = "direct";
|
||||
internalMutation = false;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const computed = new Proxy({} as C, {
|
||||
get(_target, property) {
|
||||
const fn = definition.computed?.[property as keyof C];
|
||||
return fn ? fn(publicState) : undefined;
|
||||
},
|
||||
set() {
|
||||
throw new TypeError("Computed store values are readonly");
|
||||
},
|
||||
ownKeys() {
|
||||
return Reflect.ownKeys(definition.computed ?? {});
|
||||
},
|
||||
getOwnPropertyDescriptor() {
|
||||
return { enumerable: true, configurable: true };
|
||||
},
|
||||
});
|
||||
|
||||
const lifecycleContext = {
|
||||
state: mutableState,
|
||||
runtime: options.runtime,
|
||||
request: options.request,
|
||||
routeId: options.routeId,
|
||||
};
|
||||
const runLifecycle = async (
|
||||
name: string,
|
||||
hook?: (context: typeof lifecycleContext) => void | Promise<void>,
|
||||
): Promise<void> => {
|
||||
if (!hook) return;
|
||||
const previousAction = currentAction;
|
||||
const previousMutation = internalMutation;
|
||||
currentAction = name;
|
||||
internalMutation = true;
|
||||
try {
|
||||
await hook(lifecycleContext);
|
||||
} finally {
|
||||
currentAction = previousAction;
|
||||
internalMutation = previousMutation;
|
||||
}
|
||||
};
|
||||
const initHook =
|
||||
options.runtime === "server"
|
||||
? definition.lifecycle?.serverInit
|
||||
: definition.lifecycle?.clientInit;
|
||||
const ready = runLifecycle(
|
||||
options.runtime === "server" ? "$serverInit" : "$clientInit",
|
||||
initHook,
|
||||
).then(async () => {
|
||||
if (options.runtime === "client" && options.hydration && definition.lifecycle?.hydrate) {
|
||||
await runLifecycle("$hydrate", definition.lifecycle.hydrate);
|
||||
}
|
||||
});
|
||||
|
||||
const core: StoreInstanceCore<State, C, A> = {
|
||||
name: definition.name,
|
||||
kind: definition.kind,
|
||||
state: publicState,
|
||||
computed,
|
||||
actions,
|
||||
whenReady: ready,
|
||||
reset,
|
||||
snapshot: () => readonlySnapshot(mutableState),
|
||||
hydrate(value) {
|
||||
mutate("$hydrate", () => Object.assign(mutableState, value));
|
||||
},
|
||||
serialize() {
|
||||
const result: Partial<State> = {};
|
||||
const serverKeys = new Set(Object.keys(definition.createServerState?.() ?? {}));
|
||||
for (const [key, value] of Object.entries(mutableState)) {
|
||||
if (!serverKeys.has(key)) (result as any)[key] = clone(value);
|
||||
}
|
||||
return result;
|
||||
},
|
||||
subscribe(listener) {
|
||||
listeners.add(listener);
|
||||
return () => listeners.delete(listener);
|
||||
},
|
||||
async dispose() {
|
||||
await ready;
|
||||
await runLifecycle("$dispose", definition.lifecycle?.dispose);
|
||||
listeners.clear();
|
||||
},
|
||||
};
|
||||
|
||||
return new Proxy(core as StoreInstance<State, C, A>, {
|
||||
get(target, property, receiver) {
|
||||
if (Reflect.has(target, property)) return Reflect.get(target, property, receiver);
|
||||
if (property in actions) return (actions as any)[property];
|
||||
if (property in (definition.computed ?? {})) return (computed as any)[property];
|
||||
if (property in mutableState) return (publicState as any)[property];
|
||||
return undefined;
|
||||
},
|
||||
set(_target, property) {
|
||||
throw new TypeError(
|
||||
`WRN-STORE-READONLY: ${definition.name}.${String(property)} must be changed by a store action.`,
|
||||
);
|
||||
},
|
||||
ownKeys(target) {
|
||||
return [
|
||||
...new Set([
|
||||
...Reflect.ownKeys(target),
|
||||
...Reflect.ownKeys(mutableState),
|
||||
...Reflect.ownKeys(definition.computed ?? {}),
|
||||
...Reflect.ownKeys(actions),
|
||||
]),
|
||||
];
|
||||
},
|
||||
getOwnPropertyDescriptor(target, property) {
|
||||
return (
|
||||
Reflect.getOwnPropertyDescriptor(target, property) ?? {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
}
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user