@rolster/forms 2.0.0

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export { createFormArrayProps, createFormControlProps, createFormGroupProps } from './arguments';
+export { FormArray, FormArrayControl, FormArrayGroup } from './form-array';
+export { FormControl } from './form-control';
+export { FormGroup } from './form-group';
+export * from './types';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,SAAS,EACT,gBAAgB,EAEhB,cAAc,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAgB,SAAS,EAAE,MAAM,cAAc,CAAC;AACvD,cAAc,SAAS,CAAC"}

package/dist/esm/types.d.ts

@@ -0,0 +1,127 @@
+import { ValidatorError, ValidatorFn, ValidatorResult } from '@rolster/validators';
+export type FormState<T = any> = T | undefined | null;
+export type ValidationFormType = 'control' | 'group' | 'array';
+export interface ValidationFormError<T = any> extends ValidatorError<T> {
+    type: ValidationFormType;
+}
+export type SubscriberControl<T> = (state?: FormState<T>) => void;
+export interface AbstractControl<T = any> {
+    dirty: boolean;
+    errors: ValidatorError[];
+    invalid: boolean;
+    pristine: boolean;
+    touched: boolean;
+    untouched: boolean;
+    valid: boolean;
+    value: T;
+    wrong: boolean;
+    error?: ValidatorError;
+    state?: FormState<T>;
+}
+export type AbstractControls<T extends AbstractControl = AbstractControl> = Record<string, T>;
+export interface AbstractGroupControl<T = any> extends AbstractControl<T> {
+    reset: () => void;
+    subscribe: (subscriber: SubscriberControl<T>) => Unsubscription;
+}
+export interface AbstractBaseControl<T = any> extends AbstractGroupControl<T> {
+    blur: () => void;
+    disable: () => void;
+    disabled: boolean;
+    enable: () => void;
+    enabled: boolean;
+    focus: () => void;
+    focused: boolean;
+    setState: (state?: FormState<T>) => void;
+    touch: () => void;
+    unfocused: boolean;
+    untouch: () => void;
+}
+export interface AbstractFormControl<T = any> extends AbstractBaseControl<T> {
+    setValidators: (validators?: ValidatorFn<T>[]) => void;
+}
+export type AbstractGroupControls<T extends AbstractGroupControl = AbstractGroupControl> = Record<string, T>;
+export interface AbstractGroup<T extends AbstractGroupControls = AbstractGroupControls> {
+    controls: T;
+    dirty: boolean;
+    dirties: boolean;
+    errors: ValidatorError[];
+    invalid: boolean;
+    pristine: boolean;
+    pristines: boolean;
+    touched: boolean;
+    toucheds: boolean;
+    untouched: boolean;
+    untoucheds: boolean;
+    valid: boolean;
+    wrong: boolean;
+    error?: ValidatorError;
+}
+export type StateGroup<C extends AbstractGroupControls = AbstractGroupControls> = {
+    [K in keyof C]: C[K]['state'];
+};
+export type ValueGroup<C extends AbstractGroupControls = AbstractGroupControls> = {
+    [K in keyof C]: C[K]['value'];
+};
+export type ValidatorGroupFn<C extends AbstractGroupControls = AbstractGroupControls, V = any> = (controls: C) => ValidatorResult<V>;
+export type SubscriberGroup<C extends AbstractGroupControls = AbstractGroupControls> = (state: StateGroup<C>) => void;
+export interface AbstractFormGroup<C extends AbstractGroupControls = AbstractGroupControls> extends AbstractGroup<C> {
+    reset: () => void;
+    setValidators: (validators: ValidatorGroupFn<C>[]) => void;
+    state: StateGroup<C>;
+    subscribe: (subscriber: SubscriberGroup<C>) => Unsubscription;
+    value: ValueGroup<C>;
+}
+export interface AbstractArrayControl<T = any> extends AbstractFormControl<T> {
+    uuid: string;
+}
+export type AbstractArrayGroupControls<T extends AbstractArrayControl = AbstractArrayControl> = AbstractControls<T>;
+export interface AbstractArrayGroup<C extends AbstractArrayGroupControls, R = any> extends AbstractGroup<C> {
+    setValidators: (validators: ValidatorGroupFn<C>[]) => void;
+    state: ArrayStateGroup<C>;
+    subscribe: (subscriber: SubscriberGroup<C>) => Unsubscription;
+    uuid: string;
+    value: ArrayValueGroup<C>;
+    resource?: R;
+}
+export type ArrayStateGroup<C extends AbstractArrayGroupControls> = {
+    [K in keyof C]: C[K]['state'];
+};
+export type ArrayValueGroup<C extends AbstractArrayGroupControls> = {
+    [K in keyof C]: C[K]['value'];
+};
+export type ValidatorArrayFn<T extends AbstractArrayGroupControls = AbstractArrayGroupControls, R = any, G extends AbstractArrayGroup<T, R> = AbstractArrayGroup<T, R>, V = any> = (groups: G[]) => ValidatorResult<V>;
+export interface AbstractArray<T extends AbstractArrayGroupControls = AbstractArrayGroupControls, R = any, G extends AbstractArrayGroup<T, R> = AbstractArrayGroup<T, R>> extends AbstractGroupControl<ArrayStateGroup<T>[]> {
+    controls: T[];
+    dirties: boolean;
+    groups: G[];
+    merge: (groups: G[]) => void;
+    pristines: boolean;
+    push: (group: G) => void;
+    remove: (group: G) => void;
+    set: (groups: G[]) => void;
+    setValidators: (validators: ValidatorArrayFn<T, R>[]) => void;
+    state: ArrayStateGroup<T>[];
+    toucheds: boolean;
+    untoucheds: boolean;
+    value: ArrayValueGroup<T>[];
+    wrong: boolean;
+}
+export interface FormControlProps<T = any> {
+    state?: FormState<T>;
+    validators?: ValidatorFn<T>[];
+}
+export interface FormGroupProps<C extends AbstractGroupControls = AbstractGroupControls> {
+    controls: C;
+    validators?: ValidatorGroupFn<C>[];
+}
+export interface FormArrayControlProps<T = any> extends FormControlProps<T> {
+    uuid: string;
+}
+export interface FormArrayGroupProps<C extends AbstractArrayGroupControls = AbstractArrayGroupControls, R = any> extends FormGroupProps<C> {
+    uuid: string;
+    resource?: R;
+}
+export interface FormArrayProps<C extends AbstractArrayGroupControls = AbstractArrayGroupControls, R = any, G extends AbstractArrayGroup<C, R> = AbstractArrayGroup<C, R>> {
+    groups?: G[];
+    validators?: ValidatorArrayFn<C, R>[];
+}

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":""}

package/helpers/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@rolster/forms/helpers",
+  "types": "../dist/esm/helpers.d.ts",
+  "main": "../dist/cjs/helpers.js",
+  "module": "../dist/esm/helpers.js",
+  "unpkg": "../dist/es/helpers.js",
+  "sideEffects": false
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@rolster/forms",
+  "version": "2.0.0",
+  "description": "It implements a set of classes that allow managing the control of states of the input components of the UI.",
+  "module": "dist/esm/index.js",
+  "main": "dist/cjs/index.js",
+  "unpkg": "dist/es/index.js",
+  "types": "dist/esm/index.d.ts",
+  "license": "MIT",
+  "author": "Rolster Technology <rolster.developments@gmail.com>",
+  "contributors": [
+    {
+      "name": "Daniel Andrés Castillo Pedroza",
+      "email": "ing.dacastillop@gmail.com"
+    }
+  ],
+  "files": [
+    "dist/",
+    "helpers/"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "node": "./dist/cjs/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./helpers": {
+      "types": "./dist/esm/helpers.d.ts",
+      "node": "./dist/cjs/helpers.js",
+      "require": "./dist/cjs/helpers.js",
+      "default": "./dist/esm/helpers.js"
+    }
+  },
+  "scripts": {
+    "prettier": "prettier . --write",
+    "clean": "rimraf ./dist",
+    "build": "npm run clean && tsc -p tsconfig.app.json && rollup -c rollup.config.js",
+    "test": "jest --coverage",
+    "test:watch": "jest --coverage --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@rolster/commons": "^2.0.2",
+    "@rolster/validators": "^2.0.0",
+    "rxjs": "^7.8.1",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@rollup/plugin-typescript": "^11.1.3",
+    "@rolster/types": "^1.0.9",
+    "@types/jest": "^29.5.1",
+    "@types/uuid": "^9.0.7",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.3",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.32.0",
+    "ts-jest": "^29.1.0",
+    "tslib": "^2.4.0",
+    "typescript": "^4.9.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rolster-developments/typescript-forms.git"
+  },
+  "keywords": [
+    "rolster",
+    "typescript",
+    "forms"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,13 @@
+# Rolster Helpers Forms
+
+It implements a set of classes that allow managing the control of states of the input components of the UI.
+
+## Installation
+
+```
+npm i @rolster/helpers-forms
+```
+
+## Contributing
+
+- Daniel Andrés Castillo Pedroza :rocket: