@gost-kit/svelte 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @gost-kit/svelte
 
+## 0.2.0
+
+### Minor Changes
+
+- e89218e: Add synchronous store.reset({ excluded }) with fresh scope state factories.
+
+  Breaking change for the current 0.x API: StoreConfig.initState now requires a
+  zero-argument factory, and Store gained a required reset member. Existing
+  implementers of Store (test doubles, wrappers) must add reset; adapters can use
+  common's framework-independent createReset. Replace initState: initialState()
+  with initState: initialState.
+  Excluded root scopes retain current references; all other scopes use fresh defaults
+  in a single state update. Reset does not cancel running effects or suppress late responses.
+
+  Reset failures are reported through the store's onError as ResetError with
+  kind: 'reset' and no action. StoreError now includes this variant; handlers
+  reading action/effect must first narrow kind. Without a handler, report uses the
+  existing console fallback. Errors during reset no longer propagate to its caller.
+
+### Patch Changes
+
+- Updated dependencies [3a39e51]
+- Updated dependencies [e89218e]
+  - @gost-kit/common@0.3.0
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -8,13 +8,15 @@ The store implementation lives in `src/shell/domain/createStore.svelte.ts`.
 import { createStore } from '@gost-kit/svelte';
 
 const counter = createStore<number, { type: 'IncrementAction' }, never>({
-  initState: 0,
+  initState: () => 0,
   reducer: (state) => ({ state: state + 1, effects: [] }),
   effector: async () => {},
 });
 
 await counter.dispatch({ type: 'IncrementAction' });
 // counter.state is now 1; reading it in a Svelte template is reactive.
+counter.reset();
+// counter.state is now 0.
 ```
 
 `createStore` accepts `StoreConfig` and returns `Store`, both exported from
@@ -23,9 +25,61 @@ merge or deeply proxy state. Each instance has independent state. Dispatch,
 parallel effects, awaited nested dispatch and error reporting are implemented
 by `@gost-kit/common` without a framework dependency.
 
+`initState` is a synchronous factory called without arguments once when creating
+the store and once per reset. Migrate `initState: initialState()` to
+`initState: initialState`. Each scope has its own factory; the root composes them:
+
+```ts
+import { define } from '@gost-kit/common';
+
+const usersState = define.state<UsersState>((options = {}) => ({
+  data: [],
+  errors: [],
+  ...options,
+}));
+const rootState = define.state<RootState>((options = {}) => ({
+  users: usersState(),
+  auth: authState(),
+  ...options,
+}));
+
+// In store config: initState: rootState
+// In reducer tests: rootState({ users: usersState({ errors: [apiError()] }) })
+```
+
+The factories above use application-defined state types and error/auth factories.
+Each call should allocate fresh mutable nested defaults. Supplied overrides are
+used by reference with a shallow replacement; the store does not clone them.
+`define.state(object)` shares nested defaults and cannot guarantee this freshness.
+
+`store.reset()` resets all state. `store.reset({ excluded: ['auth'] })` preserves
+the current `auth` reference and resets other scopes. The list is readonly and
+checked against root keys, not action namespaces. An absent/empty list is a full
+reset. The entire root factory runs even for excluded scopes, followed by a
+single state publication. Reset returns void and retains the same store/dispatch.
+
+Partial reset supports fixed object roots with independent scopes. Primitive,
+array, function and union roots permit full reset only at the type level; a union
+inside a scope is fine. Union detection uses the represented TypeScript type;
+type widening or assertions can erase that information. Runtime checks do not
+detect unions. An excluded key is preserved only if it is an own property of both
+the current and initial roots. Missing or inherited keys are skipped, including
+optional scopes deleted or added by reducers. Such scopes take their presence
+and value from the initial root. Errors during reset go to the store's `onError`
+as `{ kind: 'reset', error }`; reset stops without throwing outward. Factory or
+validation failures leave state unchanged. Without `onError`, the shared reporter
+logs the failure to console. Initial creation still calls the factory directly:
+if that fails, creation throws and no store is returned.
+
+Reset does not cancel pending effects or ignore late responses. A later dispatch
+reads the current state after reset and may populate it again. Routing and request
+cancellation belong to the application.
+
 The optional `onError` callback is supplied when the store is created, for example
 to connect application logging. Replacing it on the original config afterwards
 does not change the store's handler.
+The same snapshot rule applies to `initState`: replacing it on config does not
+change the factory captured by an existing store.
 
 Select a feature before computing its presentation:
 

package/dist/shell/domain/createStore.svelte.js

@@ -1,22 +1,26 @@
-import { createDispatch, } from '@gost-kit/common';
+import { createDispatch, createReset, } from '@gost-kit/common';
 export const createStore = ({ initState, reducer, effector, onError, }) => {
     // Reducers replace complete immutable state; deep proxies are unnecessary.
-    let state = $state.raw(initState);
+    let state = $state.raw(initState());
+    const readState = () => {
+        return state;
+    };
+    const writeState = (next) => {
+        state = next;
+    };
     const dispatch = createDispatch({
-        readState: () => {
-            return state;
-        },
-        writeState: (next) => {
-            state = next;
-        },
+        readState,
+        writeState,
         reducer,
         effector,
         onError,
     });
+    const reset = createReset({ initState, readState, writeState, onError });
     return {
         get state() {
             return state;
         },
         dispatch,
+        reset,
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gost-kit/svelte",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Svelte bindings for GOST functional core.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@gost-kit/common": "^0.2.0"
+    "@gost-kit/common": "^0.3.0"
   },
   "peerDependencies": {
     "svelte": "^5.57.2"