humn 1.4.1 → 1.6.0

package/dist/cortex.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Mapped type for the Memory configuration object.
+ * Allows each property to be the raw value OR a persisted wrapper.
+ * @template T
+ * @typedef { { [K in keyof T]: T[K] | import('./persist.js').Persisted<T[K]> } } MemoryInput
+ */
+/**
+ * Deeply unwraps persisted values from the memory shape.
+ * @template {object} T
+ * @typedef {{ [K in keyof T]: T[K] extends import('./persist.js').Persisted<infer I> ? I : T[K] }} UnwrappedMemory
+ */
+/**
+ * @template T
+ * @callback Getter
+ * @returns {T}
+ */
+/**
+ * @template T
+ * @callback Setter
+ * @param {Partial<T> | ((state: T) => void | Partial<T> | unknown)} updater
+ * @returns {void}
+ */
+/**
+ * @template M, S
+ * @callback SynapsesBuilder
+ * @param {Setter<M>} set
+ * @param {Getter<M>} get
+ * @returns {S}
+ */
+/**
+ * @template M, S
+ * @typedef {object} CortexConfig
+ * @property {MemoryInput<M>} memory - The initial state configuration
+ * @property {SynapsesBuilder<M, S>} synapses - The synapses builder function
+ */
+/**
+ * The Cortex class manages the state of the application.
+ *
+ * @template {object} MemoryType The shape of the application state
+ * @template {object} SynapsesType The shape of the actions/methods
+ */
+export class Cortex<MemoryType extends unknown, SynapsesType extends unknown> {
+    /**
+     * Creates an instance of Cortex.
+     * @param {CortexConfig<MemoryType, SynapsesType>} config
+     */
+    constructor({ memory, synapses }: CortexConfig<MemoryType, SynapsesType>);
+    _persistenceMap: Map<any, any>;
+    /** @type {UnwrappedMemory<MemoryType>} */
+    _memory: UnwrappedMemory<MemoryType>;
+    _listeners: Map<any, any>;
+    /** @type {SynapsesType} */
+    synapses: SynapsesType;
+    /**
+     * Creates a copy-on-write mutation draft that tracks changed paths without
+     * cloning the whole store before every mutative update.
+     */
+    _createMutationDraft(base: any, changedPaths: any): {
+        getNextState: () => any;
+        memory: any;
+    };
+    /**
+     * Only notify listeners that read properties which changed
+     */
+    _notifyRelevantListeners(changedPaths: any): void;
+    /**
+     * Creates a Proxy that tracks which properties are accessed during render
+     *
+     * WHY: This is the other half of the magic. By tracking what a component READS
+     * during its render, we build a precise dependency graph. If a component reads
+     * `state.user.name`, it will only re-render when `state.user.name` changes,
+     * not when `state.count` changes.
+     */
+    _createAccessTrackingProxy(obj: any, accessedPaths: any, path?: string): any;
+    /**
+     * @returns {UnwrappedMemory<MemoryType>}
+     */
+    get memory(): UnwrappedMemory<MemoryType>;
+}
+/**
+ * Mapped type for the Memory configuration object.
+ * Allows each property to be the raw value OR a persisted wrapper.
+ */
+export type MemoryInput<T> = { [K in keyof T]: T[K] | import("./persist.js").Persisted<T[K]>; };
+/**
+ * Deeply unwraps persisted values from the memory shape.
+ */
+export type UnwrappedMemory<T extends unknown> = { [K in keyof T]: T[K] extends import("./persist.js").Persisted<infer I> ? I : T[K]; };
+export type Getter<T> = () => T;
+export type Setter<T> = (updater: Partial<T> | ((state: T) => void | Partial<T> | unknown)) => void;
+export type SynapsesBuilder<M, S> = (set: Setter<M>, get: Getter<M>) => S;
+export type CortexConfig<M, S> = {
+    /**
+     * - The initial state configuration
+     */
+    memory: MemoryInput<M>;
+    /**
+     * - The synapses builder function
+     */
+    synapses: SynapsesBuilder<M, S>;
+};

package/dist/css.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Scoped CSS Tag.
+ * Wraps content in a unique class using Native CSS Nesting.
+ * Supports two signatures:
+ * 1. Tagged Template: css`...`
+ * 2. Function: css(string, isSingleRoot)
+ */
+export function css(stringsOrStr: any, ...args: any[]): string;

package/dist/h.d.ts

@@ -0,0 +1,7 @@
+export function cloneVNode(vNode: any): any;
+export function h(tag: string, props?: object, children?: VNode[] | VNode): VNode;
+export type VNode = {
+    tag: string;
+    props: object;
+    children: VNode[];
+};