juststore 1.2.1 → 1.2.2

package/dist/form.d.ts

@@ -1,5 +1,5 @@
 import type { FieldPath, FieldPathValue, FieldValues, IsEqual } from './path';
-import type { ArrayProxy, DerivedStateProps, ObjectMutationMethods, Prettify, ValueState } from './types';
+import type { ArrayProxy, DerivedStateProps, ObjectMutationMethods, ObjectStateValue, Prettify, ValueState } from './types';
 export { type CreateFormOptions, createForm, type DeepNonNullable, type FormArrayState, type FormObjectState, type FormState, type FormStore, type FormValueState, useForm };
 /**
  * Common form field methods available on every form state node.
@@ -35,17 +35,17 @@ interface FormValueState<T> extends Omit<ValueState<T>, 'ensureArray' | 'ensureO
      */
     derived: <R>({ from, to }: DerivedStateProps<T, R>) => FormState<R>;
 }
-type FormObjectProxy<T extends FieldValues> = {
+type FormObjectProxy<T extends FieldValues, TObject = T> = {
     /** Virtual state for the object's keys.
      *
      * This does NOT read from a real `keys` property on the stored object; it results in a stable array of keys.
      */
     readonly keys: FormReadOnlyState<FieldPath<T>[]>;
 } & {
-    [K in keyof T]-?: FormState<T[K]>;
+    [K in keyof T]-?: FormState<ObjectStateValue<TObject, T, K>>;
 };
 type FormArrayState<TValue, TArray = TValue[]> = IsEqual<TValue, unknown> extends true ? never : FormValueState<TArray> & ArrayProxy<TValue, FormState<TValue>>;
-type FormObjectState<TNonNullable extends FieldValues, TObject = TNonNullable> = FormObjectProxy<TNonNullable> & FormValueState<TObject> & ObjectMutationMethods;
+type FormObjectState<TNonNullable extends FieldValues, TObject = TNonNullable> = FormObjectProxy<TNonNullable, TObject> & FormValueState<TObject> & ObjectMutationMethods;
 /** Type for nested objects with proxy methods */
 type DeepNonNullable<T> = [NonNullable<T>] extends [readonly (infer U)[]] ? U[] : [NonNullable<T>] extends [FieldValues] ? {
     [K in keyof NonNullable<T>]-?: DeepNonNullable<NonNullable<T>[K]>;

package/dist/store.d.ts

@@ -1,6 +1,6 @@
 import type { FieldValues } from './path';
 import { type StoreOptions } from './root';
-import type { State, StoreRoot } from './types';
+import type { ObjectProxy, StoreRoot } from './types';
 export { createStore, type Store };
 /**
  * A persistent, hierarchical, cross-tab synchronized key-value store with React bindings.
@@ -13,9 +13,7 @@ export { createStore, type Store };
  * - Type-safe paths using FieldPath.
  * - Dynamic deep access via Proxy for ergonomic usage like `store.a.b.c.use()` and `store.a.b.c.set(v)`.
  */
-type Store<T extends FieldValues> = StoreRoot<T> & {
-    [K in keyof T]-?: State<T[K]>;
-};
+type Store<T extends FieldValues> = StoreRoot<T> & ObjectProxy<T>;
 /**
  * Creates a persistent, hierarchical store with localStorage backing and cross-tab synchronization.
  *

package/dist/types.d.ts

@@ -1,9 +1,11 @@
 import type { FieldPath, FieldPathValue, FieldValues, IsEqual } from './path';
-export type { AllowedKeys, ArrayProxy, ArrayState, DerivedStateProps, ObjectMutationMethods, ObjectState, Prettify, ReadOnlyState, State, StoreRoot, StoreSetStateValue, StoreUseComputeFn, StoreUseState, ValueState };
+export type { AllowedKeys, ArrayProxy, ArrayState, DerivedStateProps, ObjectMutationMethods, ObjectProxy, ObjectState, ObjectStateValue, Prettify, ReadOnlyState, State, StoreRoot, StoreSetStateValue, StoreUseComputeFn, StoreUseState, ValueState };
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 type AllowedKeys<T> = Exclude<keyof T, keyof ValueState<unknown> | keyof ObjectMutationMethods>;
+type MaybeMissingParent<TParent, TValue> = undefined extends TParent ? TValue | undefined : null extends TParent ? TValue | undefined : TValue;
+type ObjectStateValue<TObject, TNonNullable extends FieldValues, K extends keyof TNonNullable> = {} extends TNonNullable ? TNonNullable[K] | undefined : MaybeMissingParent<TObject, TNonNullable[K]>;
 type ArrayMutationMethods<T> = Prettify<Pick<Array<T>, 'push' | 'pop' | 'shift' | 'unshift' | 'splice' | 'reverse' | 'sort' | 'fill' | 'copyWithin'>>;
 /** Type for array proxy with index access */
 type ArrayProxy<T, ElementState = State<T>> = ArrayMutationMethods<NonNullable<T>> & {
@@ -25,14 +27,14 @@ type ArrayProxy<T, ElementState = State<T>> = ArrayMutationMethods<NonNullable<T
     /** Insert items into the array in sorted order using the provided comparison function. */
     sortedInsert(cmp: (a: T, b: T) => number, ...items: T[]): number;
 };
-type ObjectProxy<T extends FieldValues> = {
+type ObjectProxy<T extends FieldValues, TObject = T> = {
     /** Virtual state for the object's keys.
      *
      * This does NOT read from a real `keys` property on the stored object; it results in a stable array of keys.
      */
     readonly keys: ReadOnlyState<FieldPath<T>[]>;
 } & {
-    [K in keyof T]-?: State<T[K]>;
+    [K in keyof T]-?: State<ObjectStateValue<TObject, T, K>>;
 };
 type ObjectMutationMethods = {
     /** Rename a key in an object. */
@@ -131,7 +133,7 @@ type ValueState<T> = {
 type ReadOnlyState<T> = Prettify<Pick<ValueState<Readonly<Required<T>>>, 'value' | 'use' | 'useCompute'>>;
 type State<T> = IsEqual<T, unknown> extends true ? never : [NonNullable<T>] extends [readonly (infer U)[]] ? ArrayState<U, T> : [NonNullable<T>] extends [FieldValues] ? ObjectState<NonNullable<T>, T> : ValueState<T>;
 type ArrayState<TValue, TArray = TValue[]> = IsEqual<TValue, unknown> extends true ? never : ValueState<TArray> & ArrayProxy<TValue>;
-type ObjectState<TNonNullable extends FieldValues, TObject = TNonNullable> = ObjectProxy<TNonNullable> & ValueState<TObject> & ObjectMutationMethods;
+type ObjectState<TNonNullable extends FieldValues, TObject = TNonNullable> = ObjectProxy<TNonNullable, TObject> & ValueState<TObject> & ObjectMutationMethods;
 /** Type for useCompute function. */
 type StoreUseComputeFn<T extends FieldValues, P extends FieldPath<T>, R> = (value: FieldPathValue<T, P>) => R;
 type DerivedStateProps<T, R> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juststore",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A small, expressive, and type-safe state management library for React.",
   "keywords": [
     "hooks",