fusee-framework 1.7.0 → 1.8.0

package/framework/types/signal.d.ts

@@ -1,79 +1,147 @@
-export type SignalAccessor<T> = {
-    (): T;
-    (newValue: T): void;
-    isSignal: boolean;
-}
-
-export interface ReactiveArrayMethods<T> {
-    map<U>(callbackfn: (value: T, index: number, array: T[]) => U): Computed<U[]>;
-    filter(predicate: (value: T, index: number, array: T[]) => boolean): Computed<T[]>;
-    slice(start?: number, end?: number): Computed<T[]>;
-    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): Computed<U>;
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): Computed<T>;
-    find(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
-    findLast(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
-    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
-    findLastIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
-    every(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
-    some(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
-    includes(searchElement: T, fromIndex?: number): Computed<boolean>;
-    indexOf(searchElement: T, fromIndex?: number): Computed<number>;
-    lastIndexOf(searchElement: T, fromIndex?: number): Computed<number>;
-    at(index: number): Computed<T | undefined>;
-    concat(...items: (T | T[])[]): Computed<T[]>;
-    flat<depth extends number = 1>(depth?: depth): Computed<any[]>;
-    flatMap<U>(callback: (value: T, index: number, array: T[]) => U | U[]): Computed<U[]>;
-    join(separator?: string): Computed<string>;
-}
-
-export type ArraySignalAccessor<T extends any[]> = SignalAccessor<T> & ReactiveArrayMethods<T[number]> & {
-    push(...items: T[number][]): number;
-    pop(): T[number] | undefined;
-    shift(): T[number] | undefined;
-    unshift(...items: T[number][]): number;
-    splice(start: number, deleteCount: number, ...items: T[number][]): T[number][];
-    remove(predicate: (item: T[number], index: number) => boolean): void;
-    clear(): void;
-    sort(compareFn?: (a: T[number], b: T[number]) => number): ArraySignalAccessor<T>;
-    reverse(): ArraySignalAccessor<T>;
-}
-
-export type ComputedAccessor<T> = {
-    (): T;
-    isSignal: boolean;
-    readonly: true;
-} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-
-export type Signal<T = any> = SignalAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-export type Computed<T = any> = ComputedAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-
-type EffectRunner = {
-    (): void;
-    deps: Set<Set<EffectRunner>>;
-}
-
-export type WatchSource<T = any> = (() => T) | Signal<T> | Computed<T>
-export type WatchCallback<T = any> = (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void
-
-export interface WatchOptions {
-    immediate?: boolean;
-    equals?: (a: any, b: any) => boolean;
-}
-
-export declare function signal<T extends any[]>(initialValue: T): ArraySignalAccessor<T>
-export declare function signal<T>(initialValue: T): SignalAccessor<T>
-export declare function effect(fn: () => void): () => void
-export declare function computed<T>(fn: () => T): Computed<T>
-export declare function batch<T>(fn: () => T): T
-export declare function untrack<T>(fn: () => T): T
-export declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void
-export declare function watch<T extends any[]>(
-    sources: [...{ [K in keyof T]: WatchSource<T[K]> }],
-    callback: (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void,
-    options?: WatchOptions
-): () => void
-export declare function inspect(...args: any[]): (() => void) | void
-export declare function onCleanup(fn: () => void): void
-
-declare function setEffectHook(fn: (eff: any) => void): void
-
+export type SignalAccessor<T> = {
+    (): T;
+    (newValue: T): void;
+    isSignal: boolean;
+}
+
+export interface ReactiveArrayMethods<T> {
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U): Computed<U[]>;
+    filter(predicate: (value: T, index: number, array: T[]) => boolean): Computed<T[]>;
+    slice(start?: number, end?: number): Computed<T[]>;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): Computed<U>;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): Computed<T>;
+    find(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
+    findLast(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
+    findLastIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
+    every(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
+    some(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
+    includes(searchElement: T, fromIndex?: number): Computed<boolean>;
+    indexOf(searchElement: T, fromIndex?: number): Computed<number>;
+    lastIndexOf(searchElement: T, fromIndex?: number): Computed<number>;
+    at(index: number): Computed<T | undefined>;
+    concat(...items: (T | T[])[]): Computed<T[]>;
+    flat<depth extends number = 1>(depth?: depth): Computed<any[]>;
+    flatMap<U>(callback: (value: T, index: number, array: T[]) => U | U[]): Computed<U[]>;
+    join(separator?: string): Computed<string>;
+}
+
+export type ArraySignalAccessor<T extends any[]> = SignalAccessor<T> & ReactiveArrayMethods<T[number]> & {
+    push(...items: T[number][]): number;
+    pop(): T[number] | undefined;
+    shift(): T[number] | undefined;
+    unshift(...items: T[number][]): number;
+    splice(start: number, deleteCount: number, ...items: T[number][]): T[number][];
+    remove(predicate: (item: T[number], index: number) => boolean): void;
+    clear(): void;
+    sort(compareFn?: (a: T[number], b: T[number]) => number): ArraySignalAccessor<T>;
+    reverse(): ArraySignalAccessor<T>;
+}
+
+export type ComputedAccessor<T> = {
+    (): T;
+    isSignal: boolean;
+    readonly: true;
+} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+export type Signal<T = any> = SignalAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+export type Computed<T = any> = ComputedAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+type EffectRunner = {
+    (): void;
+    deps: Set<Set<EffectRunner>>;
+}
+
+export type WatchSource<T = any> = (() => T) | Signal<T> | Computed<T>
+export type WatchCallback<T = any> = (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void
+
+export interface WatchOptions {
+    immediate?: boolean;
+    equals?: (a: any, b: any) => boolean;
+}
+
+export interface ResourceOptions {
+    staleTime?: number;
+    key?: string | number;
+}
+
+export type ResourceAccessor<T> = {
+    (): T | undefined;
+    read(): T;
+    isSignal: boolean;
+    loading: Signal<boolean>;
+    isFetching: Signal<boolean>;
+    error: Signal<any>;
+} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+export type ResourceActions<T> = {
+    mutate: (val: T) => void;
+    refetch: () => void;
+}
+
+export type ResourceReturn<T, R = unknown> = [
+    ResourceAccessor<T>,
+    {
+        mutate: (val: T) => void;
+        refetch: () => void;
+    }
+];
+
+export interface SuspenseOptions {
+    onError?: (err: any) => void;
+}
+
+export interface SuspenseSignal<T> {
+    (): T;
+    pending: Signal<boolean>;
+    error: Signal<any>;
+}
+
+export type Resource<T> = [ResourceAccessor<T>, ResourceActions<T>]
+
+export declare function signal<T extends any[]>(initialValue: T): ArraySignalAccessor<T>
+export declare function signal<T>(initialValue: T): SignalAccessor<T>
+export declare function effect(fn: () => void): () => void
+export declare function computed<T>(fn: () => T): Computed<T>
+export declare function batch<T>(fn: () => T): T
+export declare function untrack<T>(fn: () => T): T
+export declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void
+export declare function watch<T extends any[]>(
+    sources: [...{ [K in keyof T]: WatchSource<T[K]> }],
+    callback: (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void,
+    options?: WatchOptions
+): () => void
+export declare function inspect(...args: any[]): (() => void) | void
+export declare function onCleanup(fn: () => void): void
+
+export function resource<T, R = any>(
+    fetcher: (input: R) => Promise<T>,
+    options?: { key?: string | number; staleTime?: number }
+): ResourceReturn<T, R>;
+
+export function resource<T, R>(
+    source: () => R,
+    fetcher: (input: R) => Promise<T>,
+    options?: { key?: string | number; staleTime?: number }
+): ResourceReturn<T, R>;
+
+export function createSuspense<T>(
+    renderFn: () => T,
+    fallbackFn: (() => T) | T,
+    options?: SuspenseOptions
+): [SuspenseSignal<T>, () => void];
+
+declare function setEffectHook(fn: (eff: any) => void): void
+
+export type AsyncPriority = 'high' | 'low';
+export interface AsyncJobOptions {
+    priority?: AsyncPriority;
+}
+
+export function scheduleAsyncJob(fn: () => void, opts?: AsyncJobOptions): void;
+
+export interface ResourceOptions<T = any> {
+    key?: string | number;
+    staleTime?: number;
+    fetchPriority?: AsyncPriority;
+}

package/framework/types/store.d.ts

@@ -1,8 +1,66 @@
-export function defineStore<T>(id: string, setup: () => T): () => T;
-export function resetStore(id: string): void;
-export function clearStores(): void;
-export function registerStorePlugin(plugin: (store: any, id: string) => void): void;
-
-declare global {
-    function defineStore<T>(id: string, setup: () => T): () => T;
-}
+export type MutationType = 'direct' | 'patch object' | 'patch function';
+
+export const MutationType: {
+    readonly DIRECT: 'direct';
+    readonly PATCH_OBJECT: 'patch object';
+    readonly PATCH_FUNCTION: 'patch function';
+};
+
+export interface StoreMutation {
+    type: MutationType;
+    storeId: string;
+    payload?: Record<string, any>;
+}
+
+export interface SubscribeOptions {
+    flush?: 'pre' | 'post' | 'sync';
+    detached?: boolean;
+}
+
+export type SubscribeCallback = (mutation: StoreMutation, state: any) => void;
+export type UnsubscribeFunction = () => void;
+
+export interface Store<T> {
+    readonly id: string;
+    readonly type: 'store';
+    patch(partial: Partial<{ [K in keyof T]: T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : T[K] }> | ((state: T) => void)): void;
+    subscribe(callback: SubscribeCallback, options?: SubscribeOptions): UnsubscribeFunction;
+}
+
+export type StoreHook<T> = (() => T & Store<T>) & { $id: string };
+
+export function defineStore<T>(id: string, setup: () => T): StoreHook<T>;
+export function resetStore(id: string): void;
+export function clearStores(): void;
+export function registerStorePlugin(plugin: (store: any, id: string) => void): void;
+export function useNestedStore<T>(useStoreFn: StoreHook<T>): T & Store<T>;
+
+export type StoreToRefs<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R ? import('./signal').SignalAccessor<R> : never
+}
+
+export type StoreToState<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R
+        ? import('./signal').SignalAccessor<R> extends { readonly: true }
+            ? never
+            : import('./signal').SignalAccessor<R>
+        : never
+}
+
+export type StoreToGetters<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R
+        ? import('./signal').SignalAccessor<R> extends { readonly: true }
+            ? import('./signal').SignalAccessor<R>
+            : never
+        : never
+}
+
+export function storeToRefs<T>(store: T & Store<T>): StoreToRefs<T>;
+export function storeToState<T>(store: T & Store<T>): StoreToState<T>;
+export function storeToGetters<T>(store: T & Store<T>): StoreToGetters<T>;
+
+declare global {
+    function defineStore<T>(id: string, setup: () => T): import('./store').StoreHook<T>;
+    function useNestedStore<T>(useStoreFn: import('./store').StoreHook<T>): T & Store<T>;
+    type MutationType = import('./store').MutationType;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fusee-framework",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Fusée - Signals-first JS Framework | Peak Performance",
   "main": "framework/index.js",
   "types": "framework/types/index.d.ts",

package/vite.config.js

@@ -39,9 +39,15 @@ export default defineConfig({
     test: {
         environment: 'jsdom',
         globals: true,
+        exclude: [
+            'node_modules/**',
+            'bench-node-1/**',
+            'create-fusee-go/**',
+            'dist/**'
+        ],
         typecheck: {
             enabled: true,
-            include: ['**/*.test-d.ts'],
+            include: ['framework/**/*.test-d.ts'],
         }
     }
 })