@lejdar/webdev 0.0.5 → 0.0.6

package/dist/brain/brain-context.d.ts

@@ -0,0 +1,11 @@
+import { Get, Paths } from "../util/paths";
+import { Merge, Values } from "../util/ts";
+export declare class BrainContext<Brain = any, C = unknown> {
+    // @ts-ignore
+    context: C;
+    // @ts-ignore
+    brain: Brain;
+}
+export type ContextOf<T> = Merge<Values<{
+    [path in Paths<T> & string]: Get<T, path> extends BrainContext<any, infer C> ? unknown extends C ? {} : C : {};
+}>>;

package/dist/brain/brain-developer.d.ts

@@ -0,0 +1,7 @@
+import { DeepPartial } from "../util/ts";
+import { BrainConstructor } from "./brain-implementor";
+export declare function BrainDeveloper<Base, Development = DeepPartial<Base>>(): {
+    <Options>(base: BrainConstructor<Base, Options>, development: BrainConstructor<Development, Options>): BrainConstructor<Base, Options>;
+    <Options>(base: BrainConstructor<Base, Options>, development: BrainConstructor<Development, Options>, initialize: () => Options): new (options?: {} | undefined) => Base;
+    <Context, Options>(base: BrainConstructor<Base, Context>, development: BrainConstructor<Development, Context>, initialize: (options: Options) => Context): BrainConstructor<Base, Options>;
+};

package/dist/brain/brain-implementor.d.ts

@@ -0,0 +1,11 @@
+import { ContextOf } from "./brain-context";
+export type BrainConstructor<Base, Options> = {} extends Options ? {
+    new (options?: Options): Base;
+} : {
+    new (options: Options): Base;
+};
+export declare function BrainImplementor<Base>(): {
+    <Implementation extends Base, Options>(implement: (options: Options) => Implementation): BrainConstructor<Base, Options & ContextOf<Implementation>>;
+    <Implementation extends Base, Options>(implement: (options: Options) => Implementation, initialize: () => ContextOf<Implementation>): BrainConstructor<Base, Options>;
+    <Implementation extends Base, Options, Initialization>(implement: (options: Options) => Implementation, initialize: (options: Initialization) => ContextOf<Implementation>): BrainConstructor<Base, Options & Initialization>;
+};

package/dist/brain/brain-module.d.ts

@@ -0,0 +1,2 @@
+import { type Paths, type Get } from "../util/paths";
+export type BrainModule<Brain, Module extends Paths<Brain>> = Get<Brain, Module>;

package/dist/brain/brain.d.ts

@@ -0,0 +1,5 @@
+export * from "./brain-context";
+export * from "./brain-module";
+export type * from "./brain-module";
+export * from "./brain-implementor";
+export * from "./brain-developer";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './react/react';
+export * from './primitives/primitives';
+export * from './interface/interface';
+export * from './util/util';
+export * from './brain/brain';
+export * from './reactive/reactive';

package/dist/interface/interface.d.ts

@@ -0,0 +1,3 @@
+export * from "./result";
+export * from "./operations";
+export * from "./use-result";

package/dist/interface/operations.d.ts

@@ -0,0 +1,37 @@
+import { Result, $Result } from "./result";
+export type Query<T, E> = Result<T, E>;
+export type QueryFn<T, E, Arg = never> = (arg: Arg) => Query<T, E>;
+export type ActionFn<P extends any[], T, E> = (...payload: P) => Promise<$Result<T, E>>;
+export type Action<P extends any[], T, E> = readonly [
+    ActionFn<P, T, E>,
+    Result<T, E> | undefined,
+    {
+        isLoading: boolean;
+    }
+];
+export type ResetableAction<P extends any[], T, E> = readonly [
+    ActionFn<P, T, E>,
+    Result<T, E> | undefined,
+    {
+        reset: () => void;
+        isLoading: boolean;
+    }
+];
+export declare function useAction<P extends any[], T, E>(mutateFn: (...payload: P) => Promise<Result<T, E>>, deps: any[]): ResetableAction<P, T, E>;
+export type Pagination = {
+    limit: number;
+};
+export type PageLoadingState = {
+    isLoading: true;
+} | {
+    isLoading: false;
+    hasMorePages: boolean;
+};
+export type PaginatedQuery<T, E, Arg = never> = (arg: Arg) => readonly [
+    T[],
+    {
+        loadNextPage(): void;
+        loadingState: Result<PageLoadingState, E>;
+    }
+];
+export type UsePaginatedQuery<T, E, Arg = never> = (pagination: Pagination, ...arg: [Arg] extends [never] ? [] : [Arg]) => PaginatedQuery<T, E>;

package/dist/interface/result.d.ts

@@ -0,0 +1,51 @@
+import { Await } from "../util/ts";
+export type Result<T, E> = Result.Ok<T> | Result.Fail<E>;
+export type $Result<T, E> = $Result.Ok<T> | $Result.Fail<E>;
+export declare namespace $Result {
+    type Fail<E> = {
+        ok: false;
+        error: E;
+        data?: never;
+    };
+    type Ok<T> = {
+        ok: true;
+        error?: never;
+        data: T;
+    };
+}
+export declare namespace Result {
+    type Ok<T> = $Result.Ok<T> & {
+        result: Ok<T>;
+        serialized: $Result.Ok<T>;
+    };
+    const ok: <T>(data: T) => {
+        ok: true;
+        data: T;
+        serialized: {
+            ok: true;
+            data: T;
+        };
+        readonly result: Ok<T>;
+    };
+    type Fail<E> = $Result.Fail<E> & {
+        result: Fail<E>;
+        serialized: $Result.Fail<E>;
+    };
+    const fail: <E>(error: E) => {
+        ok: false;
+        error: E;
+        serialized: {
+            ok: false;
+            error: E;
+        };
+        readonly result: Fail<E>;
+    };
+    type DataOf<R> = Await<R> & {
+        ok: true;
+    } extends Ok<infer T> ? T : never;
+    type ErrorOf<R> = Await<R> & {
+        ok: false;
+    } extends Fail<infer E> ? E : never;
+    const backlink: <T, E>(result: $Result<T, E>) => Result<T, E>;
+}
+export * from "./use-result";

package/dist/interface/use-result.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "./result";
+type UseResultHooks<T, E> = {
+    success(data: T): Result.Ok<T>;
+    error(error: E): Result.Fail<E>;
+    set(result: Result<T, E>): Result<T, E>;
+    reset(): void;
+};
+export declare function useResult<T, E>(initial: Result<T, E>): [Result<T, E>, UseResultHooks<T, E>];
+export declare function useOptionalResult<T, E>(initial?: Result<T, E>): [Result<T, E> | undefined, UseResultHooks<T, E> & {
+    reset: () => void;
+}];
+export {};

package/dist/primitives/array.d.ts

@@ -0,0 +1,4 @@
+export declare function generate<T>(length: number, map: (index: number) => T): T[];
+export declare function haveEqualItems<T>(a1: T[], a2: T[], eqauls?: (i1: T, i2: T) => boolean): boolean;
+export declare function arraify<T>(item: T | T[] | readonly T[]): T[];
+export declare function groupBy<T>(items: T[], group: (item: T) => any): T[][];

package/dist/primitives/object.d.ts

@@ -0,0 +1,11 @@
+export type Key<T> = Exclude<keyof T, symbol> & string;
+export declare function keys<T>(o: T): Key<T>[];
+export type Value<T> = T[Key<T>];
+export declare function values<T>(o: T): Value<T>[];
+export type Entry<T> = Exclude<{
+    [key in keyof T]: [key, T[key]];
+}[Exclude<keyof T, undefined>], undefined>;
+export declare function entries<T extends object>(o: T): Entry<T>[];
+export declare function fromEntries<T>(entries: Entry<T>[]): T;
+export declare function isPOJO(o: unknown): o is object;
+export declare function construct<T>(constructor: (this: T) => void): T;

package/dist/primitives/primitives.d.ts

@@ -0,0 +1,2 @@
+export * from "./array";
+export * from "./object";

package/dist/react/classNames.d.ts

@@ -0,0 +1,14 @@
+type Recursion<T> = T | Recursion<T>[];
+export type ClassNames = Recursion<Recursion<string> | null | undefined | false>;
+export type ClassNameProp<P = {}> = Omit<P, "className"> & {
+    className?: ClassNames;
+};
+export default function cn(...names: ClassNames[]): string;
+type Variants<Variant extends string> = Partial<Record<Variant, ClassNames>>;
+type VariantSwitch<Variant extends string> = Record<Variant, boolean> | Variant | false | null | undefined;
+export type VariantsOf<T> = T extends (...variants: VariantSwitch<infer Variant>[]) => any ? Variant : never;
+type ComponentStyles<Component extends string> = Partial<Record<Component, ClassNames>>;
+type ComponentVariants<Component extends string, Variant extends string> = Partial<Record<Variant, ComponentStyles<Component>>>;
+export declare function defineComponents<Variant extends string, Component extends string>(styles: ComponentStyles<Component>, variants?: ComponentVariants<Component, Variant>): (...variants: VariantSwitch<Variant>[]) => Record<Component, string>;
+export declare function defineStyle<Variant extends string>(...styling: (Variants<Variant> | ClassNames)[]): (...variants: VariantSwitch<Variant>[]) => string;
+export {};

package/dist/react/context.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from "react";
+import { Result } from "../interface/result";
+export declare const emptyContext: unique symbol;
+export default function createContex<T>(options: {
+    initial?: T;
+    debugName?: string;
+    mapProps?: (props: any) => T;
+}): {
+    readonly context: React.Context<typeof emptyContext | T>;
+    readonly useContext: () => T;
+    readonly useSafe: () => Result<T, string>;
+    readonly Provider: (props: {
+        children: ReactNode;
+    } & T) => React.FunctionComponentElement<React.ProviderProps<typeof emptyContext | T>>;
+};

package/dist/react/hooks.d.ts

@@ -0,0 +1,17 @@
+export declare function useAsync<T>(awaited: (() => Promise<T>) | Promise<T>, deps?: any[]): T;
+export type AsyncState<R> = {
+    isIdle: true;
+    result?: never;
+    isLoading: false;
+} | {
+    isIdle: false;
+    result?: never;
+    isLoading: true;
+} | {
+    isIdle: false;
+    result: R;
+    isLoading: false;
+};
+export declare function useAsyncCallback<Args extends any[], R>(fn: (...args: Args) => Promise<R>, deps?: ((...args: Args) => Promise<R>)[]): readonly [(...args: Args) => Promise<R>, AsyncState<R>];
+export declare function usePrevious<T>(value: T): [T | undefined, boolean];
+export declare function useDebounce<T>(value: T, time: number): T;

package/dist/react/react.d.ts

@@ -0,0 +1,5 @@
+export type * from "./classNames";
+export * from "./classNames";
+export { default as cn } from "./classNames";
+export { default as createContext } from "./context";
+export * from "./hooks";

package/dist/reactive/aggregate.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from "rxjs";
+import { Collection } from "./collection";
+type ItemsOf<T> = {
+    [key in keyof T]: T[key] extends Collection<infer Item> ? Item[] : never;
+};
+export declare class Aggregate<TBases extends Collection<any>[], TAggregate> extends Collection<TAggregate> {
+    // TODO: Weaken - check weakmap functionality
+    _cache: WeakMap<object, any>;
+    items: Observable<TAggregate[]>;
+    memo<T>(input: T, dependenceis: any[]): T;
+    constructor(aggregate: (...collections: ItemsOf<TBases>) => {
+        item: TAggregate;
+        dependencies: any[];
+    }[], bases: TBases);
+}
+export {};

package/dist/reactive/collection.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from "rxjs";
+export declare abstract class Collection<T> {
+    protected abstract items: Observable<T[]>;
+    static from<T>(items: T[]): Collection<T>;
+    watchOne(filter: (item: T) => boolean): Observable<T | null>;
+    watch(filter?: ((item: T) => boolean) | undefined): Observable<T[]>;
+    find(filter: (item: T) => boolean): Promise<T | null>;
+    list(filter?: (item: T, index: number) => boolean): Promise<T[]>;
+}
+export type ItemOf<C extends Collection<any>> = C extends Collection<infer T> ? T : never;

package/dist/reactive/reactive-hooks.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from "rxjs";
+import { Collection } from "./collection";
+export declare function useSuspendedObservable<T>(observable: Observable<T>): T;
+export declare function useObservable<T>(observable: Observable<T>): T | null;
+export declare function useCollection<T>(collection: Collection<T>, filter?: ((item: T) => boolean) | undefined, deps?: any[]): T[];
+export declare function useItem<T>(collection: Collection<T>, filter: (item: T) => boolean, deps?: any[]): T | null;

package/dist/reactive/reactive.d.ts

@@ -0,0 +1,4 @@
+export * from "./aggregate";
+export * from "./collection";
+export * from "./store";
+export * from "./reactive-hooks";

package/dist/reactive/store.d.ts

@@ -0,0 +1,11 @@
+import { BehaviorSubject } from "rxjs";
+import { Collection } from "./collection";
+export declare class Store<T> extends Collection<T> {
+    items: BehaviorSubject<T[]>;
+    get state(): T[];
+    set state(items: T[]);
+    constructor(items?: T[]);
+    add(item: T): T;
+    update(filter: (item: T) => boolean, map: (item: T) => T): void;
+    remove(filter: (item: T) => boolean): void;
+}

package/dist/util/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(test: boolean, message: string): void;

package/dist/util/curry.d.ts

@@ -0,0 +1,12 @@
+export declare function curry<Fn extends (...args: any[]) => any, O extends Order | undefined = undefined>(fn: Fn, order?: O, curried?: any[]): ([O] extends [undefined] ? NaturalCurry<Fn> : Curry<Fn, O>);
+type Order = readonly (number | readonly number[])[];
+type NaturalCurry<Fn> = Fn extends (...args: infer A) => infer R ? A extends [infer First, ...infer Rest] ? (arg: First) => NaturalCurry<(...args: Rest) => R> : R : never;
+type Curry<Fn extends (...args: any[]) => any, O> = O extends readonly [
+    infer First,
+    ...infer Rest
+] ? (...args: First extends readonly number[] ? [
+    ...{
+        [key in keyof First]: Parameters<Fn>[Extract<First[key], number>];
+    }
+] : [Parameters<Fn>[Extract<First, number>]]) => Curry<Fn, Rest> : ReturnType<Fn>;
+export {};

package/dist/util/guardian.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "../interface/result";
+import { IsAsync } from "./ts";
+type GuardRule = (...parameters: any[]) => Result<any, any> | Promise<Result<any, any>>;
+type GuardOptions = {
+    alwaysRun?: boolean;
+};
+type Guardian<Rule extends GuardRule, Options extends GuardOptions = {}> = {
+    data: Result.DataOf<ReturnType<Rule>> | (Options["alwaysRun"] extends true ? null : never);
+    <R>(...permissions: Parameters<Rule>): Result.Fail<Result.ErrorOf<ReturnType<Rule>>> extends (R extends Promise<infer V> ? V : R) ? (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => IsAsync<Rule> extends true ? Promise<R> : R>) => void : never;
+};
+// @ts-ignore
+export declare const Guardian: {
+    new <Rule extends GuardRule, Options extends GuardOptions = {}>(rule: Rule, options?: Options): Guardian<Rule, Options>;
+};
+export {};

package/dist/util/memo.d.ts

@@ -0,0 +1 @@
+export declare function memo<T>(input: T, dependencies: any[], cache: WeakMap<any, any>): T;

package/dist/util/paths.d.ts

@@ -0,0 +1,32 @@
+import { type Key } from "../primitives/object";
+type Decrement<Limit> = Limit extends [any, ...infer Rest] ? Rest : never;
+export type Paths<T, Exclusive = never, Limiter extends any[] = [1, 2, 3, 4, 5]> = Key<T> | {
+    [key in Key<T>]: T[key] extends object ? T[key] extends Exclusive | Function ? key : Limiter extends [any] ? key : `${key}.${Paths<T[key], Exclusive, Decrement<Limiter>>}` : key;
+}[Key<T>];
+export declare function paths<T, Exlcusive = never>(o: T, exclude?: Exlcusive[], prefix?: string): Iterable<Paths<T>>;
+export type Leafs<T, Exclusive = never, Limiter extends any[] = [1, 2, 3, 4, 5]> = {
+    [key in Key<T>]: T[key] extends Record<any, any> ? T[key] extends Exclusive | Function ? key : Limiter extends [any] ? key : `${key}.${Leafs<T[key], Exclusive, Decrement<Limiter>>}` : key;
+}[Key<T>];
+export declare function leafs<T, Exclusive = never>(o: T, exclude?: Exclusive[], prefix?: string): Iterable<Leafs<T, Exclusive>>;
+export type Get<T, P> = P extends `${infer Key}.${infer Rest}` ? Get<T[Extract<Key, keyof T>], Extract<Rest, Paths<T[Extract<Key, keyof T>]>>> : T[Extract<P, keyof T>];
+type Split<P> = P extends `${infer Key}.${infer Rest}` ? [Key, ...Split<Rest>] : [];
+export declare function get<T, P extends string>(o: T, path: P | Split<P>): Get<T, P>;
+export type Flat<T, Exclusive = never> = {
+    [key in Leafs<T, Exclusive>]: Get<T, key>;
+};
+export declare function flatten<T, Exclusive = never>(o: T, exclude?: Exclusive[]): Flat<T, Exclusive>;
+type ShallowPaths<T> = {
+    [Path in Key<T>]: Path extends `${infer Key}.${string}` ? Key : Path;
+}[Key<T>];
+type Subpaths<T, Prefix extends string> = {
+    [Path in Key<T>]: Path extends `${Prefix}.${infer Subpath}` ? Subpath : never;
+}[Key<T>];
+export type Inflated<T> = {
+    [key in ShallowPaths<T>]: key extends keyof T ? T[key] : Inflated<{
+        [subpath in Subpaths<T, key>]: T[Extract<`${key}.${subpath}`, keyof T>];
+    }>;
+};
+export declare function unflatten<T>(o: Flat<T>): T;
+export type Patch<T, P, Exclusive = never> = {} extends T ? P : {} extends P ? T : Inflated<Omit<Flat<T, Exclusive>, keyof Flat<P, Exclusive>> & Flat<P, Exclusive>>;
+export declare function patch<T, P>(original: T, patch: P): Patch<T, P>;
+export {};

package/dist/util/range.d.ts

@@ -0,0 +1,13 @@
+export declare class Range {
+    // @ts-ignore
+    readonly from: number;
+    // @ts-ignore
+    readonly to: number;
+    // @ts-ignore
+    private readonly range;
+    constructor(...definition: [RangeDefinition] | [number, number]);
+    [Symbol.iterator](): ArrayIterator<number>;
+    toArray(): number[];
+    contains(r: Range | number): boolean;
+}
+export type RangeDefinition = [number, number] | Range;

package/dist/util/ts.d.ts

@@ -0,0 +1,25 @@
+export type Fn<Args extends any[] = any[], Return = any> = (...args: Args) => Return;
+export type Recursion<T> = T | Recursion<T>[];
+export type PropsOf<T extends (...args: any[]) => any> = Parameters<T>[0];
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? T[P] extends Function ? T[P] : DeepPartial<T[P]> : T[P];
+};
+export type Merge<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
+export type DeeplyOptional<T extends object> = {
+    [key in keyof T]?: T[key] extends object ? DeeplyOptional<T[key]> : T[key];
+};
+export type NothingOrEveryhing<T extends object> = T | {
+    [key in keyof T]?: never;
+};
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type Await<T> = T extends Promise<infer V> ? V : T;
+export type IsAsync<T> = ReturnType<Extract<T, Fn>> extends Promise<any> ? true : false;
+export type RemoveNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type NeverColleasing<T, E> = [T] extends [never] ? E : T;
+export type NullishColleasing<T, E> = T extends undefined | null ? E : T;
+export type Values<T> = T[keyof T];
+export type Permutate<U extends string | symbol | number> = [U] extends [never] ? [] : {
+    [K in U]: [K, ...Permutate<Exclude<U, K>>];
+}[U];

package/dist/util/util.d.ts

@@ -0,0 +1,7 @@
+export * from "./curry";
+export * from "./memo";
+export * from "./paths";
+export * from "./ts";
+export * from "./range";
+export * from "./guardian";
+export * from './uuid';

package/dist/util/uuid.d.ts

@@ -0,0 +1 @@
+export { uuid } from "uuidv4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lejdar/webdev",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "files": [
     "dist",
@@ -51,7 +51,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "vite builde",
+    "build": "vite build && tsgo",
     "build:watch": "node build.js",
     "test": "vitest ",
     "test:ui": "vitest --ui --coverage",
@@ -81,6 +81,7 @@
     "rxjs": "^7.8.2"
   },
   "dependencies": {
+    "@lejdar/webdev": "^0.0.5",
     "@types/assert": "^1.5.11",
     "@types/node": "^22.14.1",
     "assert": "^2.1.0",