@companix/formkit 0.0.1 → 0.0.3

package/dist/Condition.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    name: string;
+    canActivate: (value: any) => boolean;
+    children: React.ReactNode;
+}
+export declare const Condition: ({ canActivate, name, children }: Props) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/Extra.d.ts

@@ -0,0 +1,7 @@
+import { SchemeItems } from './core/types';
+interface Props {
+    path: string[];
+    item: SchemeItems.Extra;
+}
+declare const ExtraScheme: ({ item, path }: Props) => import("react/jsx-runtime").JSX.Element;
+export { ExtraScheme };

package/dist/Form.d.ts

@@ -0,0 +1,7 @@
+import { SchemeItems } from './core/types';
+interface FormProps {
+    name: string;
+    item: SchemeItems.Form;
+}
+export declare const Form: ({ item: { Form: TargetForm }, name }: FormProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/SchemeBuilder.d.ts

@@ -0,0 +1,7 @@
+import { SchemeItems } from './core/types';
+export interface SchemeBuilderProps {
+    scheme: SchemeItems.All[];
+    path: string[];
+}
+declare const SchemeBuilder: ({ scheme, path }: SchemeBuilderProps) => import("react/jsx-runtime").JSX.Element;
+export { SchemeBuilder };

package/dist/context.d.ts

@@ -0,0 +1,2 @@
+import { FormManager } from './manager/manager';
+export declare const FormContext: import('react').Context<FormManager<any, any>>;

package/dist/core/builders/create-extra-form.d.ts

@@ -0,0 +1,8 @@
+import { SchemeItems } from '../types';
+type Registry = <N extends string>(name: N) => <T extends SchemeItems.All>(getItem: (name: N, remove: () => void) => T) => SchemeItems.Registry<N, T>;
+export interface ExtraFormBuilder<N extends string, T extends SchemeItems.Registry<N, SchemeItems.All>[]> {
+    getItems: (registry: Registry) => T;
+    getController: (append: (name: N) => void, visable: N[]) => React.ReactNode;
+}
+export declare const createExtraForm: <N extends string, T extends SchemeItems.Registry<N>[]>({ getItems, getController }: ExtraFormBuilder<N, T>) => SchemeItems.Extra<N, T>;
+export {};

package/dist/core/builders/create-form.d.ts

@@ -0,0 +1,27 @@
+import { FieldError, SchemeItems } from '../types';
+import { RefCallBack } from '../../types';
+export interface FieldControl<V> {
+    value: V;
+    onChange: (value: V) => void;
+    onBlur: () => void;
+    ref: RefCallBack;
+    disabled?: boolean;
+}
+export interface FormControl<V> {
+    field: FieldControl<V>;
+    isDirty: boolean;
+    disabled?: boolean;
+    error: FieldError | null;
+}
+export interface Rules<V> {
+    $rules?: {
+        required?: boolean;
+        validate?: (value: V) => void;
+    };
+}
+export interface FormBuilder<P, V> {
+    defaultValue: V;
+    getRequireCheck: (params: P) => (value: V) => void;
+    getForm: (params: P) => (control: FormControl<V>) => React.ReactNode;
+}
+export declare const createForm: <V, P>(builder: FormBuilder<P, V>) => <N extends string>(name: N, params: P & Rules<V>) => SchemeItems.Form<N, V, P>;

package/dist/core/builders/create-layout.d.ts

@@ -0,0 +1,5 @@
+import { SchemeItems } from '../types';
+export type LayoutBuilder = (props: {
+    children: React.ReactNode;
+}) => React.ReactNode;
+export declare const createLayout: <P = void>(getLayout: (params: P) => LayoutBuilder) => (params: P) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Layout<T>;

package/dist/core/builders/syntax.d.ts

@@ -0,0 +1,5 @@
+import { SchemeItems } from '../types';
+export declare const Context: <N extends string>(context: N) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Context<N, T>;
+export declare const Condition: (depended: string, props: {
+    canActivate: (value: any) => boolean;
+}) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Condition<T>;

package/dist/core/extract.d.ts

@@ -0,0 +1,13 @@
+import { SchemeItems } from './types';
+import { Compute, UnionToIntersection } from '../utils/typescript';
+type ExtractValue<T> = T extends SchemeItems.Form<infer N, infer V> ? {
+    [K in N]: V;
+} : T extends SchemeItems.Layout<infer C> ? ExtractValue<C[number]> : T extends SchemeItems.Context<infer N, infer C> ? {
+    [K in N]: Compute<UnionToIntersection<ExtractValue<C[number]>>>;
+} : T extends SchemeItems.Condition<infer C> ? Partial<ExtractValue<C[number]>> : T extends SchemeItems.Extra<string, infer C> ? Partial<ExtractValue<ReturnType<C[number]['getForm']>>> : never;
+type ExtractValues<T> = Compute<UnionToIntersection<ExtractValue<T>>>;
+type ExtractFlatValue<T, A extends string | null> = T extends SchemeItems.Form<infer N, infer V> ? {
+    [K in A extends null ? N : `${A}.${N}`]: V;
+} : T extends SchemeItems.Layout<infer C> ? ExtractFlatValue<C[number], A> : T extends SchemeItems.Context<infer N, infer C> ? ExtractFlatValue<C[number], A extends null ? N : `${A}.${N}`> : T extends SchemeItems.Condition<infer C> ? Partial<ExtractFlatValue<C[number], A>> : T extends SchemeItems.Extra<string, infer C> ? Partial<ExtractValue<ReturnType<C[number]['getForm']>>> : never;
+type ExtractFlatValues<T> = Compute<UnionToIntersection<ExtractFlatValue<T, null>>>;
+export type { ExtractValues, ExtractFlatValues };

package/dist/core/types.d.ts

@@ -0,0 +1,42 @@
+import { LayoutBuilder } from './builders/create-layout';
+import { FormBuilder } from './builders/create-form';
+export interface FieldError {
+    error: boolean;
+    messages?: string[];
+}
+export declare namespace SchemeItems {
+    type All = Form | Layout | Context | Condition | Extra;
+    interface Form<N extends string = string, V extends any = any, P extends any = any> {
+        type: 'form';
+        name: N;
+        defaultValue: V;
+        validate: (value: V) => FieldError | void;
+        Form: ReturnType<FormBuilder<P, V>['getForm']>;
+    }
+    interface Layout<T extends All[] = All[]> {
+        type: 'layout';
+        Layout: LayoutBuilder;
+        childs: T;
+    }
+    interface Context<N extends string = string, T extends All[] = All[]> {
+        type: 'context';
+        context: N;
+        childs: T;
+    }
+    interface Extra<N extends string = string, T extends Registry<N>[] = Registry<N>[]> {
+        type: 'extra';
+        items: T;
+        getController: (append: (name: N) => void, visable: N[]) => React.ReactNode;
+    }
+    interface Registry<N extends string = string, T extends All = All> {
+        type: 'registry';
+        name: N;
+        getForm: <Q extends N>(name: Q, remove: () => void) => T;
+    }
+    interface Condition<T extends All[] = All[]> {
+        type: 'condition';
+        depended: string;
+        canActivate: (value: any) => boolean;
+        childs: T;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { useForm } from './useForm';
+export { createForm } from './core/builders/create-form';
+export { createLayout } from './core/builders/create-layout';
+export { createExtraForm } from './core/builders/create-extra-form';
+export { Condition, Context } from './core/builders/syntax';
+export type { FieldError } from './core/types';

package/dist/manager/create-value.d.ts

@@ -0,0 +1,3 @@
+import { SchemeItems } from '../core/types';
+import { Forms } from './manager';
+export declare const createValues: <T>(scheme: SchemeItems.All[], forms: Forms) => T;

package/dist/manager/manager.d.ts

@@ -0,0 +1,43 @@
+import { DeepPartial, FieldValues } from '../types';
+import { FieldError, SchemeItems } from '../core/types';
+import { MainOptions, SetError } from '../useForm';
+interface FormItem {
+    isDirty: boolean;
+    error: FieldError | null;
+    initValue: any;
+    defaultValue: any;
+    value: any;
+    rerender: () => void;
+    focus?: () => void;
+    validate: (value: any) => FieldError | void;
+    subscribers: {
+        callback: () => void;
+    }[];
+}
+export interface Forms {
+    [name: string]: FormItem;
+}
+export interface FormManager<FlattenValues, ClonedValues> {
+    disabled?: boolean;
+    activate: () => void;
+    disactivate: () => void;
+    handleSubmit: () => Promise<void>;
+    registry: (name: string, callback: () => void) => {
+        unregistry: () => void;
+    };
+    subscribeToForm: (name: string, callback: () => void) => {
+        unsubscribe: () => void;
+    };
+    registryExtraForm: (names: string[], callback: () => void) => {
+        unregistry: () => void;
+    };
+    getForm: (name: string) => FormItem;
+    onChange: (name: string, value: any) => void;
+    setFocus: (name: keyof FlattenValues) => void;
+    setValue: <K extends keyof FlattenValues>(name: K, value: FlattenValues[K]) => void;
+    setError: SetError<FlattenValues>;
+    reset: (v: DeepPartial<ClonedValues>) => void;
+    getValues: () => DeepPartial<ClonedValues>;
+}
+export declare const createFormManager: <Values extends FieldValues, Flatten, Cloned>(scheme: SchemeItems.All[], opts: MainOptions<Values, Flatten, Cloned>) => FormManager<Flatten, Cloned>;
+export {};

package/dist/manager/read-scheme.d.ts

@@ -0,0 +1,5 @@
+import { FieldValues } from '../types';
+import { SchemeItems } from '../core/types';
+type cb = (item: SchemeItems.Form, name: string, value?: any) => void;
+declare const readScheme: (scheme: SchemeItems.All[], path: string[], values: FieldValues, callback: cb) => void;
+export { readScheme };

package/dist/manager/subject.d.ts

@@ -0,0 +1,10 @@
+export interface Observer<T> {
+    callback: (value: T) => void;
+}
+export interface Subject<T> {
+    call(value: T): void;
+    subscribe(observer: Observer<T>): {
+        unsubscribe(): void;
+    };
+}
+export declare const createSubject: <T>() => Subject<T>;

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+export type RefCallBack = (instance: any) => void;
+export type FieldValues = Record<string, any>;
+export type ExtractObjects<T> = T extends infer U ? (U extends object ? U : never) : never;
+declare const $NestedValue: unique symbol;
+export type BrowserNativeObject = Date | FileList | File;
+export type NestedValue<TValue extends object = object> = {
+    [$NestedValue]: never;
+} & TValue;
+export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T : {
+    [K in keyof T]?: ExtractObjects<T[K]> extends never ? T[K] : DeepPartial<T[K]>;
+};
+export {};

package/dist/useForm.d.ts

@@ -0,0 +1,61 @@
+import { ExtractValues, ExtractFlatValues } from './core/extract';
+import { SchemeItems } from './core/types';
+import { DeepPartial, FieldValues } from './types';
+export type Copy<T> = {
+    [K in keyof T]: T[K];
+};
+export type ChangeEvent<T> = Required<{
+    [K in keyof T]: {
+        name: K;
+        value: T[K];
+    };
+}[keyof T]>;
+export type DirtyEvent<T> = Required<{
+    [K in keyof T]: {
+        name: K;
+        isDirty: boolean;
+    };
+}[keyof T]>;
+export type SetError<V> = (name: keyof V, error: {
+    message: string;
+}) => void;
+export interface MainOptions<Values extends FieldValues, FlattenValues, ClonedValues> {
+    disabled?: boolean;
+    defaultValues?: DeepPartial<ClonedValues>;
+    onEqual?: () => void;
+    onDirty?: (event: DirtyEvent<FlattenValues>) => void;
+    onChangeEvent?: (event: ChangeEvent<FlattenValues>) => void;
+    onFormDirty?: (isDirty: boolean) => void;
+    onSubmit: (values: Values, { setError }: {
+        setError: SetError<FlattenValues>;
+    }) => Promise<void>;
+}
+declare const useDynamicForm: (scheme: SchemeItems.All[], opts: MainOptions<FieldValues, FieldValues, FieldValues>) => {
+    useValue: <K extends string>(name: K) => any;
+    reset: (values: {
+        [x: string]: any;
+    }) => void;
+    setFocus: (name: string) => void;
+    setError: (name: string, error: {
+        message: string;
+    }) => void;
+    setValue: <K extends string>(name: K, value: any) => void;
+    getValues: () => {
+        [x: string]: any;
+    };
+    handleSubmit: () => Promise<void>;
+    Form: import("react/jsx-runtime").JSX.Element;
+};
+declare const useForm: <Items extends SchemeItems.All[], Values extends ExtractValues<Items[number]>, FlattenValues extends ExtractFlatValues<Items[number]>, Cloned extends Copy<Values>>(scheme: Items, opts: MainOptions<Values, FlattenValues, Cloned>) => {
+    useValue: <K extends keyof FlattenValues>(name: K) => FlattenValues[K];
+    reset: (values: DeepPartial<Cloned>) => void;
+    setFocus: (name: keyof FlattenValues) => void;
+    setError: (name: keyof FlattenValues, error: {
+        message: string;
+    }) => void;
+    setValue: <K extends keyof FlattenValues>(name: K, value: FlattenValues[K]) => void;
+    getValues: () => DeepPartial<Cloned>;
+    handleSubmit: () => Promise<void>;
+    Form: import("react/jsx-runtime").JSX.Element;
+};
+export { useForm, useDynamicForm };

package/dist/useValue.d.ts

@@ -0,0 +1 @@
+export declare const useValue: (name: string) => any;

package/dist/utils/get-error.d.ts

@@ -0,0 +1,7 @@
+export declare const getError: (exec: () => void) => {
+    error: boolean;
+    messages: string[];
+} | {
+    error: boolean;
+    messages?: undefined;
+} | undefined;

package/dist/utils/get-items-names.d.ts

@@ -0,0 +1,2 @@
+import { SchemeItems } from '../core/types';
+export declare const getItemsNames: (path: string[], items: SchemeItems.All[]) => string[];

package/dist/utils/typescript.d.ts

@@ -0,0 +1,5 @@
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer R) => void ? R : never;
+type Compute<T> = {} & {
+    [P in keyof T]: T[P];
+};
+export type { UnionToIntersection, Compute };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@companix/formkit",
-  "version": "0.0.01",
+  "version": "0.0.03",
   "module": "./dist/bundle.es.js",
-  "types": "./src/index.ts",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "author": "Pavel Victorov",
   "files": [
@@ -39,6 +39,7 @@
     "sass": "^1.96.0",
     "sass-embedded": "^1.96.0",
     "vite": "^7.0.0",
-    "vite-plugin-checker": "^0.9.3"
+    "vite-plugin-checker": "^0.9.3",
+    "vite-plugin-dts": "^4.5.4"
   }
 }