zartui 3.0.2 → 3.0.3

package/lib/field/index.d.ts

@@ -0,0 +1,230 @@
+import { FieldProps } from './Field';
+export declare const Field: import("../utils").WithInstall<import("vue").DefineComponent<{
+    leftIcon: StringConstructor;
+    titleIcon: StringConstructor;
+    title: (NumberConstructor | StringConstructor)[];
+    value: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    label: (NumberConstructor | StringConstructor)[];
+    direction: {
+        type: import("vue").PropType<import("..").CellDirection>;
+        default: import("..").CellDirection;
+    };
+    center: BooleanConstructor;
+    isLink: BooleanConstructor;
+    border: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    required: BooleanConstructor;
+    iconPrefix: StringConstructor;
+    valueClass: import("vue").PropType<unknown>;
+    labelClass: import("vue").PropType<unknown>;
+    titleClass: import("vue").PropType<unknown>;
+    titleStyle: import("vue").PropType<string | import("vue").CSSProperties>;
+    arrowDirection: import("vue").PropType<import("..").CellArrowDirection>;
+    clickable: {
+        type: import("vue").PropType<boolean | null>;
+        default: null;
+    };
+} & {
+    id: StringConstructor;
+    name: StringConstructor;
+    titleIcon: StringConstructor;
+    leftIcon: StringConstructor;
+    rightIcon: StringConstructor;
+    autofocus: BooleanConstructor;
+    clearable: BooleanConstructor;
+    maxlength: (NumberConstructor | StringConstructor)[];
+    formatter: import("vue").PropType<(value: string) => string>;
+    clearIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    modelValue: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    inputAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    placeholder: StringConstructor;
+    autocomplete: StringConstructor;
+    errorMessage: StringConstructor;
+    enterkeyhint: StringConstructor;
+    clearTrigger: {
+        type: import("vue").PropType<import("./types").FieldClearTrigger>;
+        default: import("./types").FieldClearTrigger;
+    };
+    formatTrigger: {
+        type: import("vue").PropType<import("./types").FieldFormatTrigger>;
+        default: import("./types").FieldFormatTrigger;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: null;
+    };
+} & {
+    rows: (NumberConstructor | StringConstructor)[];
+    type: {
+        type: import("vue").PropType<import("./types").FieldType>;
+        default: import("./types").FieldType;
+    };
+    rules: import("vue").PropType<import("./types").FieldRule[]>;
+    autosize: import("vue").PropType<boolean | import("./types").FieldAutosizeConfig>;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelClass: import("vue").PropType<unknown>;
+    labelAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    showWordLimit: BooleanConstructor;
+    errorMessageAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    description: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    colon: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "clear" | "keypress" | "clickInput" | "endValidate" | "startValidate" | "clickLeftIcon" | "clickRightIcon" | "update:modelValue")[], "focus" | "blur" | "clear" | "keypress" | "clickInput" | "endValidate" | "startValidate" | "clickLeftIcon" | "clickRightIcon" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    leftIcon: StringConstructor;
+    titleIcon: StringConstructor;
+    title: (NumberConstructor | StringConstructor)[];
+    value: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    label: (NumberConstructor | StringConstructor)[];
+    direction: {
+        type: import("vue").PropType<import("..").CellDirection>;
+        default: import("..").CellDirection;
+    };
+    center: BooleanConstructor;
+    isLink: BooleanConstructor;
+    border: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    required: BooleanConstructor;
+    iconPrefix: StringConstructor;
+    valueClass: import("vue").PropType<unknown>;
+    labelClass: import("vue").PropType<unknown>;
+    titleClass: import("vue").PropType<unknown>;
+    titleStyle: import("vue").PropType<string | import("vue").CSSProperties>;
+    arrowDirection: import("vue").PropType<import("..").CellArrowDirection>;
+    clickable: {
+        type: import("vue").PropType<boolean | null>;
+        default: null;
+    };
+} & {
+    id: StringConstructor;
+    name: StringConstructor;
+    titleIcon: StringConstructor;
+    leftIcon: StringConstructor;
+    rightIcon: StringConstructor;
+    autofocus: BooleanConstructor;
+    clearable: BooleanConstructor;
+    maxlength: (NumberConstructor | StringConstructor)[];
+    formatter: import("vue").PropType<(value: string) => string>;
+    clearIcon: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    modelValue: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    inputAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    placeholder: StringConstructor;
+    autocomplete: StringConstructor;
+    errorMessage: StringConstructor;
+    enterkeyhint: StringConstructor;
+    clearTrigger: {
+        type: import("vue").PropType<import("./types").FieldClearTrigger>;
+        default: import("./types").FieldClearTrigger;
+    };
+    formatTrigger: {
+        type: import("vue").PropType<import("./types").FieldFormatTrigger>;
+        default: import("./types").FieldFormatTrigger;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: null;
+    };
+} & {
+    rows: (NumberConstructor | StringConstructor)[];
+    type: {
+        type: import("vue").PropType<import("./types").FieldType>;
+        default: import("./types").FieldType;
+    };
+    rules: import("vue").PropType<import("./types").FieldRule[]>;
+    autosize: import("vue").PropType<boolean | import("./types").FieldAutosizeConfig>;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelClass: import("vue").PropType<unknown>;
+    labelAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    showWordLimit: BooleanConstructor;
+    errorMessageAlign: import("vue").PropType<import("./types").FieldTextAlign>;
+    description: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    colon: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}>> & {
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onKeypress?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onClickInput?: ((...args: any[]) => any) | undefined;
+    onEndValidate?: ((...args: any[]) => any) | undefined;
+    onStartValidate?: ((...args: any[]) => any) | undefined;
+    onClickLeftIcon?: ((...args: any[]) => any) | undefined;
+    onClickRightIcon?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    type: import("./types").FieldType;
+    required: boolean;
+    autofocus: boolean;
+    disabled: boolean;
+    value: string;
+    direction: import("..").CellDirection;
+    center: boolean;
+    isLink: boolean;
+    border: boolean;
+    clickable: boolean | null;
+    clearable: boolean;
+    clearIcon: string;
+    modelValue: string | number;
+    clearTrigger: import("./types").FieldClearTrigger;
+    formatTrigger: import("./types").FieldFormatTrigger;
+    error: boolean;
+    readonly: boolean;
+    showWordLimit: boolean;
+    description: string;
+    colon: boolean;
+}>>;
+export default Field;
+export type { FieldProps };
+export type { FieldType, FieldRule, FieldInstance, FieldTextAlign, FieldRuleMessage, FieldClearTrigger, FieldFormatTrigger, FieldRuleValidator, FiledRuleFormatter, FieldValidateError, FieldAutosizeConfig, FieldValidateTrigger, FieldValidationStatus, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        ZtField: typeof Field;
+    }
+}

package/lib/field/index.js

@@ -0,0 +1,33 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Field: () => Field,
+  default: () => stdin_default
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_Field = __toESM(require("./Field"));
+const Field = (0, import_utils.withInstall)(import_Field.default);
+var stdin_default = Field;

package/lib/field/style/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/field/style/index.js

@@ -0,0 +1,5 @@
+require("../../style/base.css");
+require("../../badge/index.css");
+require("../../icon/index.css");
+require("../../cell/index.css");
+require("../index.css");

package/lib/field/types.d.ts

@@ -0,0 +1,44 @@
+import type { ComputedRef, ComponentPublicInstance } from 'vue';
+import type { FieldProps } from './Field';
+export declare type FieldType = 'tel' | 'url' | 'date' | 'file' | 'text' | 'time' | 'week' | 'color' | 'digit' | 'email' | 'image' | 'month' | 'radio' | 'range' | 'reset' | 'button' | 'hidden' | 'number' | 'search' | 'submit' | 'checkbox' | 'password' | 'textarea' | 'datetime-local';
+export declare type FieldTextAlign = 'left' | 'center' | 'right';
+export declare type FieldClearTrigger = 'always' | 'focus';
+export declare type FieldFormatTrigger = 'onBlur' | 'onChange';
+export declare type FieldValidateTrigger = 'onBlur' | 'onChange' | 'onSubmit';
+export declare type FieldAutosizeConfig = {
+    maxHeight?: number;
+    minHeight?: number;
+};
+export declare type FieldValidateError = {
+    name?: string;
+    message: string;
+};
+export declare type FieldRuleMessage = string | ((value: any, rule: FieldRule) => string);
+export declare type FieldRuleValidator = (value: any, rule: FieldRule) => boolean | string | Promise<boolean | string>;
+export declare type FiledRuleFormatter = (value: any, rule: FieldRule) => string;
+export declare type FieldRule = {
+    pattern?: RegExp;
+    trigger?: FieldValidateTrigger | FieldValidateTrigger[];
+    message?: FieldRuleMessage;
+    required?: boolean;
+    validator?: FieldRuleValidator;
+    formatter?: FiledRuleFormatter;
+    validateEmpty?: boolean;
+};
+export declare type FieldValidationStatus = 'passed' | 'failed' | 'unvalidated';
+export declare type FieldFormSharedProps = 'colon' | 'disabled' | 'readonly' | 'labelWidth' | 'labelAlign' | 'inputAlign' | 'errorMessageAlign';
+export declare type FieldExpose = {
+    blur: () => void | undefined;
+    focus: () => void | undefined;
+    validate: (rules?: FieldRule[] | undefined) => Promise<void | FieldValidateError>;
+    resetValidation: () => void;
+    getValidationStatus: () => FieldValidationStatus;
+    /** @private */
+    formValue: ComputedRef<unknown>;
+};
+export declare type FieldInstance = ComponentPublicInstance<FieldProps, FieldExpose>;
+declare global {
+    interface EventTarget {
+        composing?: boolean;
+    }
+}

package/lib/field/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/field/utils.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, InputHTMLAttributes } from 'vue';
+import type { FieldRule, FieldType, FieldAutosizeConfig } from './types';
+export declare function isEmptyValue(value: unknown): boolean;
+export declare function runSyncRule(value: unknown, rule: FieldRule): boolean;
+export declare function runRuleValidator(value: unknown, rule: FieldRule): Promise<unknown>;
+export declare function getRuleMessage(value: unknown, rule: FieldRule): string;
+export declare function startComposing({ target }: Event): void;
+export declare function endComposing({ target }: Event): void;
+export declare function resizeTextarea(input: HTMLInputElement, autosize: true | FieldAutosizeConfig): void;
+export declare function mapInputType(type: FieldType): {
+    type: InputHTMLAttributes['type'];
+    inputmode?: HTMLAttributes['inputmode'];
+};
+export declare function getStringLength(str: string): number;
+export declare function cutString(str: string, maxlength: number): string;

package/lib/field/utils.js

@@ -0,0 +1,120 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  cutString: () => cutString,
+  endComposing: () => endComposing,
+  getRuleMessage: () => getRuleMessage,
+  getStringLength: () => getStringLength,
+  isEmptyValue: () => isEmptyValue,
+  mapInputType: () => mapInputType,
+  resizeTextarea: () => resizeTextarea,
+  runRuleValidator: () => runRuleValidator,
+  runSyncRule: () => runSyncRule,
+  startComposing: () => startComposing
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+function isEmptyValue(value) {
+  if (Array.isArray(value)) {
+    return !value.length;
+  }
+  if (value === 0) {
+    return false;
+  }
+  return !value;
+}
+function runSyncRule(value, rule) {
+  if (isEmptyValue(value)) {
+    if (rule.required) {
+      return false;
+    }
+    if (rule.validateEmpty === false) {
+      return true;
+    }
+  }
+  if (rule.pattern && !rule.pattern.test(String(value))) {
+    return false;
+  }
+  return true;
+}
+function runRuleValidator(value, rule) {
+  return new Promise((resolve) => {
+    const returnVal = rule.validator(value, rule);
+    if ((0, import_utils.isPromise)(returnVal)) {
+      returnVal.then(resolve);
+      return;
+    }
+    resolve(returnVal);
+  });
+}
+function getRuleMessage(value, rule) {
+  const { message } = rule;
+  if ((0, import_utils.isFunction)(message)) {
+    return message(value, rule);
+  }
+  return message || "";
+}
+function startComposing({ target }) {
+  target.composing = true;
+}
+function endComposing({ target }) {
+  if (target.composing) {
+    target.composing = false;
+    target.dispatchEvent(new Event("input"));
+  }
+}
+function resizeTextarea(input, autosize) {
+  const scrollTop = (0, import_utils.getRootScrollTop)();
+  input.style.height = "auto";
+  let height = input.scrollHeight;
+  if ((0, import_utils.isObject)(autosize)) {
+    const { maxHeight, minHeight } = autosize;
+    if (maxHeight !== void 0) {
+      height = Math.min(height, maxHeight);
+    }
+    if (minHeight !== void 0) {
+      height = Math.max(height, minHeight);
+    }
+  }
+  if (height) {
+    input.style.height = `${height}px`;
+    (0, import_utils.setRootScrollTop)(scrollTop);
+  }
+}
+function mapInputType(type) {
+  if (type === "number") {
+    return {
+      type: "text",
+      inputmode: "decimal"
+    };
+  }
+  if (type === "digit") {
+    return {
+      type: "tel",
+      inputmode: "numeric"
+    };
+  }
+  return { type };
+}
+function getStringLength(str) {
+  return [...str].length;
+}
+function cutString(str, maxlength) {
+  return [...str].slice(0, maxlength).join("");
+}

package/lib/form/Form.d.ts

@@ -0,0 +1,88 @@
+import { type PropType, type ExtractPropTypes } from 'vue';
+import type { FieldTextAlign, FieldValidateTrigger } from '../field/types';
+declare const formProps: {
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+};
+export declare type FormProps = ExtractPropTypes<typeof formProps>;
+declare const _default: import("vue").DefineComponent<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("submit" | "failed")[], "submit" | "failed", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+}>> & {
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onFailed?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    readonly: boolean;
+    colon: boolean;
+    showError: boolean;
+    scrollToError: boolean;
+    validateFirst: boolean;
+    submitOnEnter: boolean;
+    showErrorMessage: boolean;
+    validateTrigger: FieldValidateTrigger | FieldValidateTrigger[];
+}>;
+export default _default;