@idem.agency/form-builder 0.0.12 → 0.0.13

package/src/entity/inputs/ui/input/index.tsx

@@ -1,31 +0,0 @@
-import type { FormElementProps, FormFieldConfig, FormFieldBase, RC } from '../../../../shared/types/common';
-import { useId } from "react";
-
-export type TextFieldConfig = FormFieldBase & { type: 'text' | 'email' | 'password';  placeholder?: string; };
-
-function isTextFieldConfig(field: FormFieldConfig): field is TextFieldConfig {
-  return field.type === 'text' || field.type === 'email' || field.type === 'password';
-}
-
-export const TextField: RC<FormElementProps> = ({ field, value, errors, onChange }) => {
-  if (!isTextFieldConfig(field)) {
-    console.warn(`TextField received an invalid field config for type: ${field.type}`);
-    return null;
-  }
-  const id = useId();
-  return (
-    <div style={{ marginBottom: '15px' }}>
-      <label htmlFor={id}>{field.label}:</label>
-      <input
-        type={field.type}
-        id={id}
-        name={field.name}
-        placeholder={field.placeholder}
-        value={value || ''}
-        onChange={(e) => onChange(e.target.value)}
-        style={{ borderColor: errors ? 'red' : '#ccc' }}
-      />
-      {errors && <p style={{ color: 'red', fontSize: '0.8em' }}>{Object.values(errors).join(', ')}</p>}
-    </div>
-  );
-};

package/src/plugins/validation/index.ts

@@ -1,39 +0,0 @@
-import { Validation } from './validation';
-import type { IPlugin, IPluginContext } from '@/shared/model/plugins/types';
-import type { IUserRule } from './types';
-
-export type TValidator = {
-  rules?: IUserRule[];
-  onSubmit?: boolean;
-};
-
-export function createValidationPlugin(config?: TValidator): IPlugin {
-  const engine = new Validation(
-    config?.onSubmit ?? false,
-    config?.rules ?? []
-  );
-
-  return {
-    name: 'validation',
-    install(ctx: IPluginContext) {
-      ctx.events.tap<{ path: string; field: { validation?: string[] } }>(
-        'field:register',
-        ({ path, field }) => {
-          engine.registerField(path, field.validation ?? []);
-        }
-      );
-
-      ctx.pipeline.use('field:change', (data, next) => {
-        const errors = engine.validate(data.field.validation ?? [], data.value, data.formData);
-        return next({ ...data, errors });
-      });
-
-      ctx.pipeline.use('form:validate', (data, next) => {
-        const errors = engine.validateAll(data.formData);
-        return next({ ...data, errors });
-      });
-    },
-  };
-}
-
-export type { IUserRule };

package/src/plugins/validation/rules/confirm.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { confirm } from './confirm'
-
-describe('confirm rule', () => {
-  it('returns true for matching values', () => {
-    const data = { password: 'secret' }
-    expect(confirm.fn('secret', data, ['password'])).toBe(true)
-  })
-
-  it('returns false for non-matching values', () => {
-    const data = { password: 'secret' }
-    expect(confirm.fn('wrong', data, ['password'])).toBe(false)
-  })
-
-  it('returns false when no args provided (attr === false)', () => {
-    expect(confirm.fn('value', {}, [])).toBe(false)
-  })
-
-  it('returns true for nested field path', () => {
-    const data = { user: { password: 'abc' } }
-    expect(confirm.fn('abc', data, ['user.password'])).toBe(true)
-  })
-})

package/src/plugins/validation/rules/confirm.ts

@@ -1,11 +0,0 @@
-import type {IUserRule} from "@/plugins/validation/types";
-import {getNestedValue} from "@/shared/utils";
-
-export const confirm: IUserRule = {
-  code: 'confirm',
-  fn: (value, data, args) => {
-    const attr = args[0] ?? false;
-    return attr ? value == getNestedValue(data, attr) : false;
-  },
-  message: 'Поле не совпадает с ::attr(1)'
-};

package/src/plugins/validation/rules/email.test.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { email } from './email'
-
-describe('email rule', () => {
-  it('returns true for valid email', () => {
-    expect(email.fn('user@example.com', {}, [])).toBe(true)
-  })
-
-  it('returns false without @', () => {
-    expect(email.fn('userexample.com', {}, [])).toBe(false)
-  })
-
-  it('returns false without domain', () => {
-    expect(email.fn('user@', {}, [])).toBe(false)
-  })
-
-  it('returns false for empty string', () => {
-    expect(email.fn('', {}, [])).toBe(false)
-  })
-})

package/src/plugins/validation/rules/email.ts

@@ -1,10 +0,0 @@
-import type {IUserRule} from "@/plugins/validation/types";
-
-const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-export const email: IUserRule = {
-  code: 'email',
-  fn: (value) => {
-    return emailRegex.test(value);
-  },
-  message: 'Поле не является email'
-};

package/src/plugins/validation/rules/index.ts

@@ -1,5 +0,0 @@
-import { confirm } from "@/plugins/validation/rules/confirm";
-import { required } from "@/plugins/validation/rules/required";
-import {email} from "@/plugins/validation/rules/email";
-
-export default [confirm, required, email]

package/src/plugins/validation/rules/required.test.ts

@@ -1,24 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { required } from './required'
-
-describe('required rule', () => {
-  it('returns false for empty string', () => {
-    expect(required.fn('', {}, [])).toBe(false)
-  })
-
-  it('returns false for undefined', () => {
-    expect(required.fn(undefined, {}, [])).toBe(false)
-  })
-
-  it('returns false for null', () => {
-    expect(required.fn(null, {}, [])).toBe(false)
-  })
-
-  it('returns true for non-empty string', () => {
-    expect(required.fn('hello', {}, [])).toBe(true)
-  })
-
-  it('returns true for string with spaces (length > 0)', () => {
-    expect(required.fn('  ', {}, [])).toBe(true)
-  })
-})

package/src/plugins/validation/rules/required.ts

@@ -1,9 +0,0 @@
-import type {IUserRule} from "@/plugins/validation/types";
-
-export const required: IUserRule = {
-  code: 'required',
-  fn: (value) => {
-    return value !== undefined && value !== null && value.length > 0;
-  },
-  message: 'Поле обязательно для заполнения'
-};

package/src/plugins/validation/types/index.ts

@@ -1,7 +0,0 @@
-import type { FormData } from "@/shared/types/common";
-
-export interface IUserRule {
-  code: string,
-  fn: (value: any, data: FormData, args: string[]) => boolean,
-  message: string
-}

package/src/plugins/validation/validation.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { Validation } from './validation'
-import type { IUserRule } from './types'
-
-describe('Validation', () => {
-  describe('validate()', () => {
-    it('returns [] when onSubmit=true', () => {
-      const v = new Validation(true)
-      expect(v.validate(['required'], '', {})).toEqual([])
-    })
-
-    it('returns errors when onSubmit=false', () => {
-      const v = new Validation(false)
-      const errors = v.validate(['required'], '', {})
-      expect(errors.length).toBeGreaterThan(0)
-    })
-
-    it('returns [] when value is valid', () => {
-      const v = new Validation(false)
-      expect(v.validate(['required'], 'hello', {})).toEqual([])
-    })
-  })
-
-  describe('validateAll()', () => {
-    it('validates all registered fields', () => {
-      const v = new Validation(false)
-      v.registerField('name', ['required'])
-      v.registerField('email', ['email'])
-      const errors = v.validateAll({ name: '', email: 'notanemail' })
-      expect(errors.name).toBeDefined()
-      expect(errors.email).toBeDefined()
-    })
-
-    it('returns empty object when all fields are valid', () => {
-      const v = new Validation(false)
-      v.registerField('name', ['required'])
-      const errors = v.validateAll({ name: 'John' })
-      expect(errors).toEqual({})
-    })
-  })
-
-  it('unknown rule code returns null (no error added)', () => {
-    const v = new Validation(false)
-    const errors = v.validate(['unknownRule'], 'value', {})
-    expect(errors).toEqual([])
-  })
-
-  it('replaceMessageArgs substitutes ::attr(N) in message', () => {
-    const customRule: IUserRule = {
-      code: 'minLen',
-      fn: (value: any, _data: any, args: string[]) => String(value).length >= Number(args[0]),
-      message: 'Min length is ::attr(0)',
-    }
-    const v = new Validation(false, [customRule])
-    const errors = v.validate(['minLen:5'], 'hi', {})
-    expect(errors[0]).toBe('Min length is 5')
-  })
-
-  it('custom rules merge with built-in rules', () => {
-    const customRule: IUserRule = {
-      code: 'custom',
-      fn: () => false,
-      message: 'Custom error',
-    }
-    const v = new Validation(false, [customRule])
-    expect(v.validate(['required'], '', {})).toHaveLength(1)
-    expect(v.validate(['custom'], 'anything', {})).toHaveLength(1)
-  })
-})

package/src/plugins/validation/validation.ts

@@ -1,57 +0,0 @@
-import type {FormData} from "@/shared/types/common";
-import base from './rules';
-import type {IUserRule} from "@/plugins/validation/types";
-import {getNestedValue} from "@/shared/utils";
-
-export class Validation {
-  private readonly registry: IUserRule[] = [];
-  private registerFields: Record<string, string[]> = {};
-  constructor(public readonly onSubmit: boolean, rules: IUserRule[] = []) {
-    this.registry = [...rules, ...base];
-  }
-  
-  
-  private validateRule(rule: string, data: unknown, formData: FormData): string|null {
-    const [code, rawArgs] = rule.split(':');
-    const args = rawArgs ? rawArgs.split(',') : [];
-    const userRule = this.registry.find(i => i.code == code);
-    if (!userRule) {
-      return null;
-    }
-    const validateStatus = userRule.fn(data, formData, args);
-    return !validateStatus ? this.replaceMessageArgs(userRule.message, args) : null;
-  }
-  
-  private replaceMessageArgs(message: string, args: string[] = []): string {
-    const replaceArgs = args.reduce<Record<string, string>>((acc, arg, index) => {
-      acc[`::attr(${index})`] = arg;
-      return acc;
-    }, {});
-
-    return message.replace(/::attr\(\d\)/g, i => replaceArgs[i]);
-  }
-  
-  public registerField(path: string, validators: string[]): void {
-    this.registerFields[path] = validators;
-  }
-
-  private _validate(rules: string[], data: unknown, formData: FormData): string[] {
-    return rules.map((rule) => {
-      return this.validateRule(rule, data, formData);
-    }).filter(i => i !== null)
-  }
-  validate(rules: string[], data: unknown, formData: FormData): string[] {
-    return !this.onSubmit ? this._validate(rules, data, formData) : [];
-  }
-  
-  public validateAll(formData: FormData): Record<string, string[]> {
-    return Object.entries(this.registerFields).reduce<Record<string, string[]>>((acc, [path, rules]) => {
-      const value = getNestedValue(formData, path);
-      const validationMessage = this._validate(rules, value, formData);
-      if (validationMessage.length) {
-        acc[path] = validationMessage;
-      }
-      return acc;
-    } , {});
-  }
-}

package/src/plugins/visibility/core.ts

@@ -1,56 +0,0 @@
-import type {TEqualRule, TGroupRules, TInRule, TCommonRule} from "@/plugins/visibility/types";
-import type {FormData} from "@/shared/types/common";
-import {getNestedValue} from "@/shared/utils";
-export class VisibilityCore {
-  private registerFields: Record<string, TGroupRules> = {};
-
-  registerField(path: string, rule: TGroupRules): void {
-    this.registerFields[path] = rule;
-  }
-  
-  private static isGroupRule(i: TGroupRules | TCommonRule): i is TGroupRules {
-    return 'rules' in i;
-  }
-  
-  private static isInOperator(i: TCommonRule): i is TInRule  {
-    return i.operator == 'in' ;
-  }
-  
-  private static isEqualOperand(i: TCommonRule): i is TEqualRule  {
-    return i.operator == '=' ;
-  }
-  
-  static checkGroup(groupRule: TGroupRules, formData: FormData): boolean {
-    const logic = groupRule.logic;
-    const items: boolean[] = [];
-    groupRule.rules.forEach((rule: TGroupRules | TCommonRule) => {
-      if (this.isGroupRule(rule)) {
-        items.push(this.checkGroup(rule, formData));
-      } else {
-        const value = getNestedValue(formData, rule.field)
-        if (this.isInOperator(rule)) {
-          items.push(rule.value.indexOf(value) !== -1);
-        } else if (this.isEqualOperand(rule)) {
-          items.push(rule.value == value);
-        }
-      }
-    })
-    if (logic == 'or') {
-      return items.indexOf(true) != -1
-    } else {
-      return items.indexOf(false) == -1;
-    }
-  }
-  
-  isView(path: string, data: FormData): boolean {
-    const rule = this.checkInRule(path);
-    if (!this.checkInRule(path)) {
-      return true;
-    }
-    return VisibilityCore.checkGroup(rule, data);
-  }
-  
-  private checkInRule(path: string) {
-    return this.registerFields[path];
-  }
-}

package/src/plugins/visibility/index.ts

@@ -1,25 +0,0 @@
-import type {IPlugin, IPluginContext} from "~/src";
-import {VisibilityCore} from "@/plugins/visibility/core";
-import type {TGroupRules} from "@/plugins/visibility/types";
-
-export function createVisibilityPlugin(): IPlugin {
-  const engine = new VisibilityCore();
-  return {
-    name: 'visibility',
-    install(ctx: IPluginContext) {
-      ctx.events.tap<{ path: string; field: { visibility?: TGroupRules } }>(
-        'field:register',
-        ({ path, field }) => {
-          if (field.visibility) {
-            engine.registerField(path, field.visibility);
-          }
-        }
-      );
-      
-      ctx.pipeline.useSync('field:visible', (data, next) => {
-        const visible = engine.isView(data.path, data.formData);
-        return next({ ...data, visible});
-      });
-    },
-  };
-}

package/src/plugins/visibility/types.ts

@@ -1,20 +0,0 @@
-export type TInRule = {
-  operator: 'in',
-  value: (string | number | boolean)[]
-} & TCommonRule
-
-export type TEqualRule = {
-  operator: '=',
-  value: string | number | boolean
-} & TCommonRule
-
-export type TCommonRule = {
-  operator: string,
-  field: string,
-  value: any,
-};
-
-export type TGroupRules = {
-  logic: 'and' | 'or',
-  rules: (TGroupRules | TCommonRule)[]
-}

package/src/shared/hook/useUpdateEffect.tsx

@@ -1,23 +0,0 @@
-import {
-  useEffect,
-  useRef,
-  type DependencyList,
-  type EffectCallback,
-} from 'react';
-
-/**
- * Хук как useEffect, но не выполняется на первом рендере.
- * Выполняется только на обновлениях, когда меняются зависимости.
- */
-export const useUpdateEffect = (effect: EffectCallback, deps: DependencyList): void => {
-  const isFirstRenderRef = useRef(true);
-
-  useEffect(() => {
-    if (isFirstRenderRef.current) {
-      isFirstRenderRef.current = false;
-      return;
-    }
-
-    return effect();
-  }, deps);
-};

package/src/shared/model/index.ts

@@ -1,12 +0,0 @@
-import { z } from 'zod';
-
-const fieldShema = z.object({
-  name: z.string(),
-  label: z.string().optional(),
-  type: z.string(),
-});
-
-type TField = z.infer<typeof fieldShema>;
-
-export type { TField };
-export { fieldShema };

package/src/shared/model/plugins/EventBus.ts

@@ -1,15 +0,0 @@
-import type { IEventBus } from './types';
-
-export class EventBus implements IEventBus {
-  private listeners = new Map<string, Set<(data: any) => void>>();
-
-  on<T = unknown>(event: string, handler: (data: T) => void): () => void {
-    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
-    this.listeners.get(event)!.add(handler);
-    return () => this.listeners.get(event)?.delete(handler);
-  }
-
-  emit<T = unknown>(event: string, data: T): void {
-    this.listeners.get(event)?.forEach((h) => h(data));
-  }
-}

package/src/shared/model/plugins/FieldRegistry.ts

@@ -1,15 +0,0 @@
-import type { IFieldRegistry } from './types';
-import type { FormElementComponent } from '@/shared/types/common';
-
-export class FieldRegistry implements IFieldRegistry {
-  private components = new Map<string, FormElementComponent<any>>();
-
-  register(type: string, component: FormElementComponent<any>): () => void {
-    this.components.set(type, component);
-    return () => this.components.delete(type);
-  }
-
-  getAll(): Record<string, FormElementComponent<any>> {
-    return Object.fromEntries(this.components);
-  }
-}

package/src/shared/model/plugins/HookRegistry.ts

@@ -1,21 +0,0 @@
-import type { FormHookName, HookHandler, IEventRegistry } from './types';
-
-export class HookRegistry implements IEventRegistry {
-  private handlers = new Map<string, Set<HookHandler<any>>>();
-
-  tap<T>(hook: FormHookName, handler: HookHandler<T>): () => void {
-    if (!this.handlers.has(hook)) {
-      this.handlers.set(hook, new Set());
-    }
-    this.handlers.get(hook)!.add(handler as HookHandler<any>);
-    return () => {
-      this.handlers.get(hook)?.delete(handler as HookHandler<any>);
-    };
-  }
-
-  async call<T>(hook: FormHookName, data: T): Promise<void> {
-    const set = this.handlers.get(hook);
-    if (!set) return;
-    await Promise.all([...set].map((h) => h(data)));
-  }
-}

package/src/shared/model/plugins/MiddlewareRegistry.ts

@@ -1,17 +0,0 @@
-import type { IMiddlewareRegistry, StoreMiddleware } from './types';
-
-export class MiddlewareRegistry implements IMiddlewareRegistry {
-  private middlewares: StoreMiddleware[] = [];
-
-  use(middleware: StoreMiddleware): () => void {
-    this.middlewares.push(middleware);
-    return () => {
-      const i = this.middlewares.indexOf(middleware);
-      if (i >= 0) this.middlewares.splice(i, 1);
-    };
-  }
-
-  getAll(): StoreMiddleware[] {
-    return [...this.middlewares];
-  }
-}

package/src/shared/model/plugins/PipelineRegistry.ts

@@ -1,73 +0,0 @@
-import type {
-  AsyncPipelineName,
-  SyncPipelineName,
-  PipelineStage,
-  SyncPipelineStage,
-  IPipelineRegistry,
-  AsyncPipelineDataMap,
-  SyncPipelineDataMap,
-} from './types';
-
-type SortedAsyncStage<T> = { stage: PipelineStage<T>; priority: number };
-type SortedSyncStage<T> = { stage: SyncPipelineStage<T>; priority: number };
-
-export class PipelineRegistry implements IPipelineRegistry {
-  private stages = new Map<string, SortedAsyncStage<any>[]>();
-  private syncStages = new Map<string, SortedSyncStage<any>[]>();
-
-  use<K extends AsyncPipelineName>(
-    pipeline: K,
-    stage: PipelineStage<AsyncPipelineDataMap[K]>,
-    priority = 10
-  ): () => void {
-    if (!this.stages.has(pipeline)) this.stages.set(pipeline, []);
-    const arr = this.stages.get(pipeline)!;
-    const entry = { stage, priority };
-    arr.push(entry);
-    arr.sort((a, b) => b.priority - a.priority);
-    return () => {
-      const i = arr.indexOf(entry);
-      if (i >= 0) arr.splice(i, 1);
-    };
-  }
-
-  useSync<K extends SyncPipelineName>(
-    pipeline: K,
-    stage: SyncPipelineStage<SyncPipelineDataMap[K]>,
-    priority = 10
-  ): () => void {
-    if (!this.syncStages.has(pipeline)) this.syncStages.set(pipeline, []);
-    const arr = this.syncStages.get(pipeline)!;
-    const entry = { stage, priority };
-    arr.push(entry);
-    arr.sort((a, b) => b.priority - a.priority);
-    return () => {
-      const i = arr.indexOf(entry);
-      if (i >= 0) arr.splice(i, 1);
-    };
-  }
-
-  async run<K extends AsyncPipelineName>(
-    name: K,
-    initialData: AsyncPipelineDataMap[K]
-  ): Promise<AsyncPipelineDataMap[K]> {
-    const arr = this.stages.get(name) ?? [];
-    const compose = (index: number) => (data: AsyncPipelineDataMap[K]): Promise<AsyncPipelineDataMap[K]> => {
-      if (index >= arr.length) return Promise.resolve(data);
-      return arr[index].stage(data, compose(index + 1));
-    };
-    return compose(0)(initialData);
-  }
-
-  runSync<K extends SyncPipelineName>(
-    name: K,
-    initialData: SyncPipelineDataMap[K]
-  ): SyncPipelineDataMap[K] {
-    const arr = this.syncStages.get(name) ?? [];
-    const compose = (index: number) => (data: SyncPipelineDataMap[K]): SyncPipelineDataMap[K] => {
-      if (index >= arr.length) return data;
-      return arr[index].stage(data, compose(index + 1));
-    };
-    return compose(0)(initialData);
-  }
-}