native-document 1.0.14 → 1.0.16-8.1

package/src/components/form/types/fields/HiddenField.d.ts

@@ -0,0 +1,26 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type HiddenFieldDescription = {
+    name: string;
+    type: 'hidden';
+    value: ObservableItem<unknown> | null;
+    defaultValue: unknown;
+    props: GlobalAttributes;
+};
+
+export interface HiddenFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: HiddenFieldDescription, instance: HiddenFieldInterface) => ValidChild): this;
+}
+
+
+export declare function HiddenField(name: string, props?: GlobalAttributes): HiddenFieldInterface;
+export declare namespace HiddenField {
+
+
+    function use(template: (description: HiddenFieldDescription, instance: HiddenFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/ImageField.d.ts

@@ -0,0 +1,45 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FileFieldInterface } from './FileField';
+import type { FileItemPreviewInterface } from './FileItemPreview';
+
+export type ImageFieldDescription = {
+    name: string;
+    type: 'image';
+    label: ValidChild | null;
+    accept: string;
+    multiple: boolean;
+    mode: string | null;
+    files: ObservableItem<FileItemPreviewInterface[]>;
+    maxWidth: number | null;
+    maxHeight: number | null;
+    crop: boolean;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface ImageFieldInterface extends Omit<FileFieldInterface, 'render'> {
+    render(renderFn: (description: ImageFieldDescription, instance: ImageFieldInterface) => ValidChild): this;
+    maxWidth(width: number): this;
+    maxHeight(height: number): this;
+    crop(enabled?: boolean): this;
+    dimensions(width: number, height: number, message?: string): this;
+    maxDimensions(width: number, height: number, message?: string): this;
+    minDimensions(width: number, height: number, message?: string): this;
+    aspectRatio(ratio: number, message?: string): this;
+}
+
+
+export declare function ImageField(name: string, props?: GlobalAttributes): ImageFieldInterface;
+export declare namespace ImageField {
+
+
+    function use(template: (description: ImageFieldDescription, instance: ImageFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/NumberField.d.ts

@@ -0,0 +1,48 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type NumberFieldDescription = {
+    name: string;
+    type: string;
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<number> | null;
+    step: number | null;
+    decimals: number | null;
+    prefix: ValidChild | null;
+    suffix: ValidChild | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface NumberFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: NumberFieldDescription, instance: NumberFieldInterface) => ValidChild): this;
+    min(min: number, message?: string): this;
+    max(max: number, message?: string): this;
+    between(min: number, max: number, message?: string): this;
+    integer(message?: string): this;
+    positive(message?: string): this;
+    unsigned(): this;
+    negative(message?: string): this;
+    multipleOf(n: number, message?: string): this;
+    step(value: number): this;
+    decimals(value?: number): this;
+    prefix(text: ValidChild): this;
+    suffix(text: ValidChild): this;
+}
+
+
+export declare function NumberField(name: string, type?: string, props?: GlobalAttributes): NumberFieldInterface;
+export declare namespace NumberField {
+
+
+    function use(template: (description: NumberFieldDescription, instance: NumberFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/PasswordField.d.ts

@@ -0,0 +1,46 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type PasswordFieldDescription = {
+    name: string;
+    type: 'password';
+    label: ValidChild | null;
+    value: ObservableItem<string> | null;
+    visibilityToggle: boolean;
+    visibilityIcons: { show: ValidChild; hide: ValidChild };
+    showStrengthMeter: boolean;
+    strengthLabels: Record<number, string> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface PasswordFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: PasswordFieldDescription, instance: PasswordFieldInterface) => ValidChild): this;
+    strong(message?: string): this;
+    containsNumber(message?: string): this;
+    containsUppercase(message?: string): this;
+    containsLowercase(message?: string): this;
+    containsSpecialChar(message?: string): this;
+    visibilityToggle(enabled?: boolean, icons?: { show?: ValidChild; hide?: ValidChild }): this;
+    visibilityIcons(show: ValidChild, hide: ValidChild): this;
+    showStrengthMeter(enabled?: boolean): this;
+    strengthLabels(labels?: { weak?: string; fair?: string; good?: string; strong?: string; veryStrong?: string }): this;
+    same(fieldName: string, message?: string): this;
+    different(fieldName: string, message?: string): this;
+}
+
+
+export declare function PasswordField(name: string, props?: GlobalAttributes): PasswordFieldInterface;
+export declare namespace PasswordField {
+
+
+    function use(template: (description: PasswordFieldDescription, instance: PasswordFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/RadioField.d.ts

@@ -0,0 +1,48 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+interface RadioOption {
+    value: unknown;
+    label: ValidChild;
+    props: GlobalAttributes;
+}
+
+export type RadioFieldDescription = {
+    name: string;
+    type: 'radio';
+    label: ValidChild | null;
+    options: RadioOption[];
+    layout: 'vertical' | 'horizontal' | 'grid';
+    checked: ObservableItem<unknown> | boolean;
+    value: ObservableItem<unknown> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface RadioFieldInterface extends Omit<FieldInterface, 'render' | 'model'> {
+    render(renderFn: (description: RadioFieldDescription, instance: RadioFieldInterface) => ValidChild): this;
+    options(opts: RadioOption[]): this;
+    option(value: unknown, label: ValidChild, props?: GlobalAttributes): this;
+    model(observable: ObservableItem<unknown>): this;
+    checked(): unknown;
+    layout(value: 'vertical' | 'horizontal' | 'grid'): this;
+    horizontal(): this;
+    vertical(): this;
+    grid(): this;
+}
+
+
+export declare function RadioField(name: string, props?: GlobalAttributes): RadioFieldInterface;
+export declare namespace RadioField {
+
+
+    function use(template: (description: RadioFieldDescription, instance: RadioFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/RangeField.d.ts

@@ -0,0 +1,44 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { NumberFieldInterface } from './NumberField';
+
+export type RangeFieldDescription = {
+    name: string;
+    type: 'range';
+    label: ValidChild | null;
+    value: ObservableItem<number> | null;
+    step: number | null;
+    min: number | null;
+    max: number | null;
+    showValue: boolean;
+    marks: number[] | Array<{ value: number; label?: ValidChild }> | null;
+    showMarks: boolean;
+    vertical: boolean;
+    showTooltip: boolean;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface RangeFieldInterface extends Omit<NumberFieldInterface, 'render'> {
+    render(renderFn: (description: RangeFieldDescription, instance: RangeFieldInterface) => ValidChild): this;
+    showValue(enabled?: boolean): this;
+    marks(marks: number[] | Array<{ value: number; label?: ValidChild }>): this;
+    showMarks(enabled?: boolean): this;
+    vertical(enabled?: boolean): this;
+    showTooltip(enabled?: boolean): this;
+}
+
+
+export declare function RangeField(name: string, props?: GlobalAttributes): RangeFieldInterface;
+export declare namespace RangeField {
+
+
+    function use(template: (description: RangeFieldDescription, instance: RangeFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/SearchField.d.ts

@@ -0,0 +1,34 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type SearchFieldDescription = {
+    name: string;
+    type: 'search';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<string> | null;
+    debounce: number;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface SearchFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: SearchFieldDescription, instance: SearchFieldInterface) => ValidChild): this;
+    debounce(ms: number): this;
+}
+
+
+export declare function SearchField(name: string, props?: GlobalAttributes): SearchFieldInterface;
+export declare namespace SearchField {
+
+
+    function use(template: (description: SearchFieldDescription, instance: SearchFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/SelectField.d.ts

@@ -0,0 +1,71 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+interface SelectOption {
+    value: unknown;
+    label: ValidChild;
+    props: GlobalAttributes;
+}
+
+interface SelectGroup {
+    label: ValidChild;
+    options: SelectOption[];
+}
+
+export type SelectFieldDescription = {
+    name: string;
+    type: 'select';
+    label: ValidChild | null;
+    options: SelectOption[];
+    multiple: boolean;
+    searchable: boolean;
+    searchPlaceholder: string | null;
+    clearable: boolean;
+    groups: SelectGroup[] | null;
+    multipleDisplay: 'text' | 'tags' | 'count' | 'truncate';
+    truncateMax: number | null;
+    removeSelected: boolean;
+    renderItem: ((item: unknown, isSelected: boolean) => ValidChild) | null;
+    truncateRender: ((count: number) => ValidChild) | false;
+    countRender: ((count: number) => ValidChild) | false;
+    selectedLabelRender: ((selected: unknown[]) => ValidChild) | false;
+    value: ObservableItem<unknown> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface SelectFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: SelectFieldDescription, instance: SelectFieldInterface) => ValidChild): this;
+    options(opts: SelectOption[]): this;
+    option(value: unknown, label: ValidChild, props?: GlobalAttributes): this;
+    multiple(enabled?: boolean): this;
+    searchable(enabled?: boolean, placeholder?: string | null): this;
+    groups(groupsConfig: SelectGroup[]): this;
+    multipleDisplay(mode: 'text' | 'tags' | 'count' | 'truncate'): this;
+    multipleDisplayAsTags(): this;
+    multipleDisplayAsText(): this;
+    multipleDisplayAsCount(): this;
+    multipleDisplayAsTruncate(max?: number): this;
+    removeSelected(enabled?: boolean): this;
+    truncateRender(callback: (count: number) => ValidChild): this;
+    countRender(callback: (count: number) => ValidChild): this;
+    selectedLabelRender(callback: (selected: unknown[]) => ValidChild): this;
+    renderItem(callback: (item: unknown, isSelected: boolean) => ValidChild): this;
+    onChange(handler: (value: unknown) => void): this;
+}
+
+
+export declare function SelectField(name: string, props?: GlobalAttributes): SelectFieldInterface;
+export declare namespace SelectField {
+
+
+    function use(template: (description: SelectFieldDescription, instance: SelectFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/StringField.d.ts

@@ -0,0 +1,48 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type StringFieldDescription = {
+    name: string;
+    type: string;
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    help: ValidChild | null;
+    defaultValue: unknown;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    value: ObservableItem<string> | null;
+    clearable: boolean | ObservableItem<boolean> | null;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    clearButtonIcon: ValidChild | null;
+    focus: ObservableItem<boolean>;
+    isDirty: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface StringFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: StringFieldDescription, instance: StringFieldInterface) => ValidChild): this;
+    minLength(min: number, message?: string): this;
+    maxLength(max: number, message?: string): this;
+    length(length: number, message?: string): this;
+    pattern(regex: RegExp, message?: string): this;
+    alphaOnly(message?: string): this;
+    numericOnly(message?: string): this;
+    alphaNumeric(message?: string): this;
+    noSpaces(message?: string): this;
+    lowercase(message?: string): this;
+    uppercase(message?: string): this;
+}
+
+
+export declare function StringField(name: string, type?: string, props?: GlobalAttributes): StringFieldInterface;
+export declare namespace StringField {
+
+
+    function use(template: (description: StringFieldDescription, instance: StringFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/TelField.d.ts

@@ -0,0 +1,37 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type TelFieldDescription = {
+    name: string;
+    type: 'tel';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<string> | null;
+    countryCode: boolean;
+    mask: string | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface TelFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: TelFieldDescription, instance: TelFieldInterface) => ValidChild): this;
+    phone(message?: string): this;
+    countryCode(enabled?: boolean): this;
+    mask(pattern: string): this;
+}
+
+
+export declare function TelField(name: string, props?: GlobalAttributes): TelFieldInterface;
+export declare namespace TelField {
+
+
+    function use(template: (description: TelFieldDescription, instance: TelFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/TextAreaField.d.ts

@@ -0,0 +1,44 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type TextAreaFieldDescription = {
+    name: string;
+    type: 'textarea';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<string> | null;
+    rows: number;
+    cols: number | null;
+    resize: 'none' | 'horizontal' | 'vertical' | 'both';
+    autoGrow: boolean;
+    characterCounter: boolean;
+    wordCount: boolean;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface TextAreaFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: TextAreaFieldDescription, instance: TextAreaFieldInterface) => ValidChild): this;
+    rows(value: number): this;
+    cols(value: number): this;
+    resize(value: 'none' | 'horizontal' | 'vertical' | 'both'): this;
+    autoGrow(enabled?: boolean): this;
+    characterCounter(enabled?: boolean): this;
+    wordCount(min: number, max: number, message?: string): this;
+}
+
+
+export declare function TextAreaField(name: string, props?: GlobalAttributes): TextAreaFieldInterface;
+export declare namespace TextAreaField {
+
+
+    function use(template: (description: TextAreaFieldDescription, instance: TextAreaFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/TimeField.d.ts

@@ -0,0 +1,51 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type TimeFieldDescription = {
+    name: string;
+    type: 'time';
+    label: ValidChild | null;
+    format: string;
+    step: number | null;
+    clearable: ObservableItem<boolean>;
+    range: ObservableItem<boolean>;
+    valueStart: ObservableItem<unknown> | null;
+    valueEnd: ObservableItem<unknown> | null;
+    rangeSeparator: string | null;
+    value: ObservableItem<unknown> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface TimeFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: TimeFieldDescription, instance: TimeFieldInterface) => ValidChild): this;
+    format(formatString: string): this;
+    step(seconds: number): this;
+    range(enabled?: boolean): this;
+    modelStart(observable: ObservableItem<unknown>): this;
+    modelEnd(observable: ObservableItem<unknown>): this;
+    rangeSeparator(sep: string): this;
+    onChange(handler: (value: unknown) => void): this;
+    onClear(handler: () => void): this;
+    min(time: string, message?: string): this;
+    max(time: string, message?: string): this;
+    between(startTime: string, endTime: string, message?: string): this;
+    after(time: string, message?: string): this;
+    before(time: string, message?: string): this;
+}
+
+
+export declare function TimeField(name: string, props?: GlobalAttributes): TimeFieldInterface;
+export declare namespace TimeField {
+
+
+    function use(template: (description: TimeFieldDescription, instance: TimeFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/UrlField.d.ts

@@ -0,0 +1,35 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type UrlFieldDescription = {
+    name: string;
+    type: 'url';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<string> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface UrlFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: UrlFieldDescription, instance: UrlFieldInterface) => ValidChild): this;
+    url(message?: string): this;
+    protocol(allowedProtocols: string[], message?: string): this;
+    domain(allowedDomains: string[], message?: string): this;
+}
+
+
+export declare function UrlField(name: string, props?: GlobalAttributes): UrlFieldInterface;
+export declare namespace UrlField {
+
+
+    function use(template: (description: UrlFieldDescription, instance: UrlFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/utils.js

@@ -0,0 +1,17 @@
+
+export function resolveParams(rule, values) {
+    return rule.params ?rule.params.map(param => {
+        if (typeof param === 'string') {
+            if(values.$parent && param.startsWith('@')) {
+                const paramName = param.substring(1);
+                if(values.$parent[paramName] !== undefined) {
+                    return values.$parent[paramName];
+                }
+            }
+            if(values[param] !== undefined) {
+                return values[param];
+            }
+        }
+        return param;
+    }): [];
+}