seitu 0.1.0 → 0.2.1

package/README.md

@@ -15,10 +15,10 @@ To quick start you only need to write the following code:
 
 ```tsx
 import { useSubscription } from 'seitu/react'
-import { sessionStorageValue } from 'seitu/web'
+import { createSessionStorageValue } from 'seitu/web'
 import * as z from 'zod'
 
-const value = sessionStorageValue({
+const value = createSessionStorageValue({
   key: 'test',
   defaultValue: 0,
   schema: z.number(),
@@ -30,7 +30,7 @@ value.remove()
 value.subscribe(v => console.log(v))
 
 function Counter() {
-  const count = useSubscription(() => value)
+  const count = useSubscription(value)
 
   return (
     <div>

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-export * from './store';
+export * from './schema-store';
 export * from './subscription';

package/dist/core/schema-store.d.ts

@@ -0,0 +1,19 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Simplify } from '../utils';
+import type { Readable, Subscribable, Writable } from './index';
+export type SchemaStoreSchema = Record<string, StandardSchemaV1<unknown, unknown>>;
+export type SchemaStoreOutput<S extends SchemaStoreSchema> = Simplify<{
+    [K in keyof S]: StandardSchemaV1.InferOutput<S[K]>;
+}>;
+export interface SchemaStore<O extends Record<string, unknown>> extends Subscribable<O>, Readable<O>, Writable<Partial<O>> {
+    getDefaultValue: <K extends keyof O>(key: K) => O[K];
+}
+export interface SchemaStoreOptions<S extends Record<string, StandardSchemaV1>> {
+    schemas: S;
+    defaultValues: SchemaStoreOutput<S>;
+    provider: {
+        get: () => SchemaStoreOutput<S>;
+        set: (value: Partial<SchemaStoreOutput<S>>) => void;
+    };
+}
+export declare function createSchemaStore<S extends Record<string, StandardSchemaV1>>(options: SchemaStoreOptions<S>): SchemaStore<SchemaStoreOutput<S>>;

package/dist/core/subscription.d.ts

@@ -1,7 +1,13 @@
 export interface Subscribable<V> {
     'subscribe': (callback: (value: V) => any) => () => void;
     '~': {
+        /**
+         * Type type with returned value of the subscription.
+         */
         output: V;
+        /**
+         * A function that notifies all subscribers that the value has changed.
+         */
         notify: () => void;
     };
 }

package/dist/core.js

@@ -1,2 +1,2 @@
 import { n as e, t } from "./core-CuCUF5Aj.js";
-export { e as createStore, t as createSubscription };
+export { e as createSchemaStore, t as createSubscription };

package/dist/react/hooks.d.ts

@@ -1,20 +1,24 @@
 import type { Readable, Subscribable } from '../core/index';
+import * as React from 'react';
+export interface UseSubscriptionOptions<S extends Subscribable<any> & Readable<any>, R = S['~']['output']> {
+    selector?: (value: S['~']['output']) => R;
+    deps?: React.DependencyList;
+}
 /**
- * Use this hook to subscribe to a reactive value. The factory function is called only
- * once on first render — subsequent renders reuse the cached subscription.
+ * Use this hook to subscribe to a reactive value. Accepts a subscription object
+ * directly, or a factory function that is called only once on first render —
+ * subsequent renders reuse the cached subscription unless dependency array changes.
  *
- * @kind hook
- *
- * @example
+ * @example Inline subscription
  * ```tsx twoslash title="/app/page.tsx"
  * 'use client'
  *
- * import { sessionStorageValue } from 'seitu/web'
+ * import { createSessionStorageValue } from 'seitu/web'
  * import { useSubscription } from 'seitu/react'
  * import * as z from 'zod'
  *
  * export default function Page() {
- *   const value = useSubscription(() => sessionStorageValue({
+ *   const value = useSubscription(() => createSessionStorageValue({
  *     key: 'test',
  *     defaultValue: 0,
  *     schema: z.number(),
@@ -24,7 +28,26 @@ import type { Readable, Subscribable } from '../core/index';
  * }
  * ```
  *
- * @example
+ * @example Instance outside of component
+ * ```tsx twoslash title="/app/page.tsx"
+ * 'use client'
+ *
+ * import { createSessionStorage } from 'seitu/web'
+ * import { useSubscription } from 'seitu/react'
+ * import * as z from 'zod'
+ *
+ * const sessionStorage = createSessionStorage({
+ *   schemas: { count: z.number(), name: z.string() },
+ *   defaultValues: { count: 0, name: '' },
+ * })
+ *
+ * export default function Page() {
+ *   const value = useSubscription(sessionStorage)
+ *   return <div>{value.count}</div>
+ * }
+ * ```
+ *
+ * @example Subscription with selector
  * ```tsx twoslash title="/app/page.tsx"
  * 'use client'
  *
@@ -42,10 +65,30 @@ import type { Readable, Subscribable } from '../core/index';
  *
  * export default function Page() {
  *   // Usage with selector, re-renders only when count changes
- *   const count = useSubscription(() => sessionStorage, value => value.count)
+ *   const count = useSubscription(sessionStorage, { selector: value => value.count })
  *
  *   return <div>{count}</div>
  * }
  * ```
+ *
+ * @example Ref example
+ * ```tsx twoslash title="/app/page.tsx"
+ * 'use client'
+ *
+ * import * as React from 'react'
+ * import { scrollState } from 'seitu/web'
+ * import { useSubscription } from 'seitu/react'
+ *
+ * export default function Page() {
+ *   const ref = React.useRef<HTMLDivElement>(null)
+ *   const state = useSubscription(() => scrollState({ element: () => ref.current, direction: 'vertical' }))
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       {String(state.top.value)}
+ *     </div>
+ *   )
+ * }
+ * ```
  */
-export declare function useSubscription<S extends Subscribable<any> & Readable<any>, R = S['~']['output']>(factory: () => S, selector?: (value: S['~']['output']) => R): R;
+export declare function useSubscription<S extends Subscribable<any> & Readable<any>, R = S['~']['output']>(source: S | (() => S), options?: UseSubscriptionOptions<S, R>): R;