@byyuurin/ui 0.0.11 → 0.1.0

package/dist/runtime/locale/zh_tw.d.ts

@@ -0,0 +1,31 @@
+declare const _default: Required<import("@byyuurin/ui-kit").Locale<{
+    alert: {
+        close: string;
+    };
+    calendar: {
+        prevYear: string;
+        nextYear: string;
+        prevMonth: string;
+        nextMonth: string;
+    };
+    carousel: {
+        dots: string;
+        prev: string;
+        next: string;
+        goto: string;
+    };
+    inputNumber: {
+        increment: string;
+        decrement: string;
+    };
+    modal: {
+        close: string;
+    };
+    table: {
+        noData: string;
+    };
+    toast: {
+        close: string;
+    };
+}>>;
+export default _default;

package/dist/runtime/locale/{zh-tw.js → zh_tw.js}

@@ -1,4 +1,4 @@
-import { defineLocale } from "../utils/index.js";
+import { defineLocale } from "../utils/locale.js";
 export default defineLocale({
   name: "\u7E41\u9AD4\u4E2D\u6587",
   code: "zh-TW",
@@ -13,6 +13,7 @@ export default defineLocale({
       nextMonth: "\u4E0B\u500B\u6708"
     },
     carousel: {
+      dots: "\u9078\u64C7\u8981\u986F\u793A\u7684\u6295\u5F71\u7247",
       prev: "\u4E0A\u4E00\u9801",
       next: "\u4E0B\u4E00\u9801",
       goto: "\u8DF3\u8F49\u5230\u7B2C {page} \u9801"

package/dist/runtime/plugins/colors.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/colors.js

@@ -0,0 +1,50 @@
+import { colors } from "@unocss/preset-wind4/colors";
+import { computed } from "vue";
+import { defineNuxtPlugin, useAppConfig, useHead, useNuxtApp } from "#imports";
+const themeShades = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+function getColor(color, shade) {
+  if (color in colors && typeof colors[color] === "object" && shade in colors[color])
+    return colors[color][shade];
+  return "";
+}
+function generateShades(key, value) {
+  return themeShades.map((shade) => `--ui-color-${key}-${shade}: var(--colors-${value === "neutral" ? "tw-neutral" : value}-${shade}, ${getColor(value, shade)});`).join("\n  ");
+}
+function generateColor(key, shade) {
+  return `--ui-${key}: var(--ui-color-${key}-${shade});`;
+}
+export default defineNuxtPlugin(() => {
+  const appConfig = useAppConfig();
+  const nuxtApp = useNuxtApp();
+  const root = computed(() => {
+    const { neutral, ...colors2 } = appConfig.ui.colors;
+    return `:root {
+  ${Object.entries(appConfig.ui.colors).map(([key, value]) => generateShades(key, value)).join("\n  ")}
+}
+:root,
+.light {
+  ${Object.keys(colors2).map((key) => generateColor(key, 500)).join("\n  ")}
+}
+.dark {
+  ${Object.keys(colors2).map((key) => generateColor(key, 400)).join("\n  ")}
+}
+`;
+  });
+  const headData = {
+    style: [{
+      innerHTML: () => root.value,
+      tagPriority: -2,
+      id: "ui-colors"
+    }]
+  };
+  if (import.meta.client && nuxtApp.isHydrating && !nuxtApp.payload.serverRendered) {
+    const style = document.createElement("style");
+    style.innerHTML = root.value;
+    style.dataset.uiColors = "";
+    document.head.append(style);
+    headData.script = [{
+      innerHTML: "document.head.removeChild(document.querySelector('[data-ui-colors]'))"
+    }];
+  }
+  useHead(headData);
+});

package/dist/runtime/types/app.config.d.ts

@@ -0,0 +1,6 @@
+declare module '#build/app.config' {
+  import type { AppConfig } from '@nuxt/schema'
+
+  const _default: AppConfig
+  export default _default
+}

package/dist/runtime/types/form.d.ts

@@ -1,6 +1,31 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { FormExpose } from './components.js';
-export type FormSchema<_T> = StandardSchemaV1;
+import type { Struct as SuperstructSchema } from 'superstruct';
+import type { ComputedRef, DeepReadonly, Ref } from 'vue';
+import type { GetObjectField, MaybeNull } from './utils';
+export interface Form<S extends FormSchema> {
+    validate: <T extends boolean>(opts?: {
+        name?: keyof FormData<S, false> | (keyof FormData<S, false>)[];
+        silent?: boolean;
+        nested?: boolean;
+        transform?: T;
+    }) => Promise<FormData<S, T> | false>;
+    clear: (path?: keyof FormData<S, false> | string | RegExp) => void;
+    errors: Ref<FormError[]>;
+    setErrors: (errs: FormError[], name?: keyof FormData<S, false> | string | RegExp) => void;
+    getErrors: (name?: keyof FormData<S, false> | string | RegExp) => FormError[];
+    submit: () => Promise<void>;
+    disabled: ComputedRef<boolean>;
+    dirty: ComputedRef<boolean>;
+    loading: Ref<boolean>;
+    dirtyFields: ReadonlySet<DeepReadonly<keyof FormData<S, false>>>;
+    touchedFields: ReadonlySet<DeepReadonly<keyof FormData<S, false>>>;
+    blurredFields: ReadonlySet<DeepReadonly<keyof FormData<S, false>>>;
+}
+export type FormSchema<I extends object = object, O extends object = I> = SuperstructSchema<any, any> | StandardSchemaV1<I, O>;
+export type InferInput<Schema> = Schema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<Schema> : Schema extends SuperstructSchema<infer I, any> ? I : Schema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<Schema> : never;
+export type InferOutput<Schema> = Schema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Schema> : Schema extends SuperstructSchema<infer O, any> ? O : never;
+export type FormData<S extends FormSchema, T extends boolean = true> = T extends true ? InferOutput<S> : InferInput<S>;
+export type FormInputEvents = 'input' | 'blur' | 'change' | 'focus';
 export interface FormError<P extends string = string> {
     name?: P;
     message: string;
@@ -8,15 +33,21 @@ export interface FormError<P extends string = string> {
 export interface FormErrorWithId extends FormError {
     id?: string;
 }
-export type FormInputEvents = 'input' | 'blur' | 'change' | 'focus';
-export type FormEventType = FormInputEvents;
 export type FormSubmitEvent<T> = SubmitEvent & {
     data: T;
 };
-export interface FormChildAttachEvent {
+export interface FormValidationError {
+    errors: FormErrorWithId[];
+    children?: FormErrorWithId[];
+}
+export type FormErrorEvent = SubmitEvent & FormValidationError;
+export type FormEventType = FormInputEvents;
+export interface FormChildAttachEvent<S extends FormSchema> {
     type: 'attach';
     formId: string | number;
-    validate: FormExpose<any>['validate'];
+    validate: Form<any>['validate'];
+    name?: string;
+    api: Form<S>;
 }
 export interface FormChildDetachEvent {
     type: 'detach';
@@ -27,19 +58,29 @@ export interface FormInputEvent<T extends object> {
     name: keyof T;
     eager?: boolean;
 }
-export type FormEvent<T extends object> = FormInputEvent<T> | FormChildAttachEvent | FormChildDetachEvent;
-export interface FormValidationError {
-    errors: FormErrorWithId[];
-    children?: FormValidationError[];
+export type FormEvent<T extends object> = FormInputEvent<T> | FormChildAttachEvent<any> | FormChildDetachEvent;
+export interface FormInjectedOptions {
+    disabled?: boolean;
+    validateOnInputDelay?: number;
+}
+export interface FormFieldInjectedOptions<T> {
+    name?: string;
+    size?: GetObjectField<T, 'size'>;
+    error?: string | boolean;
+    eagerValidation?: boolean;
+    validateOnInputDelay?: number;
+    errorPattern?: RegExp;
+    hint?: string;
+    description?: string;
+    help?: string;
+    ariaId: string;
 }
-export type FormErrorEvent = SubmitEvent & FormValidationError;
 export interface ValidateReturnSchema<T> {
     result: T;
-    errors: FormError[] | null;
+    errors: MaybeNull<FormError[]>;
 }
-export interface FormValidateOptions<T extends object> {
-    name?: keyof T | (keyof T)[];
-    silent?: boolean;
-    nested?: boolean;
-    transform?: boolean;
+export declare class FormValidationException extends Error {
+    formId: string | number;
+    errors: FormErrorWithId[];
+    constructor(formId: string | number, errors: FormErrorWithId[]);
 }

package/dist/runtime/types/form.js

@@ -0,0 +1,11 @@
+export class FormValidationException extends Error {
+  formId;
+  errors;
+  // eslint-disable-next-line unicorn/custom-error-definition
+  constructor(formId, errors) {
+    super("Form validation exception");
+    this.formId = formId;
+    this.errors = errors;
+    Object.setPrototypeOf(this, FormValidationException.prototype);
+  }
+}

package/dist/runtime/types/index.d.ts

@@ -1,9 +1,52 @@
-import type * as theme from '../theme/index.js';
-export * from './components.js';
-export * from './form.js';
-export * from './locale.js';
-export * from './utils.js';
-type MergeThemes<T> = {
-    [P in keyof T as T[P] extends undefined ? never : P]?: T[P] extends Array<infer V> ? V extends string ? string : V[] : T[P] extends object ? MergeThemes<T[P]> : T[P] extends string ? string : T[P];
+import type { AppConfig } from '@nuxt/schema';
+import type { AppConfigUI } from '#build/types/ui';
+export * from '../components/Accordion.vue';
+export * from '../components/Alert.vue';
+export * from '../components/App.vue';
+export * from '../components/Avatar.vue';
+export * from '../components/AvatarGroup.vue';
+export * from '../components/Badge.vue';
+export * from '../components/Breadcrumb.vue';
+export * from '../components/Button.vue';
+export * from '../components/Calendar.vue';
+export * from '../components/Card.vue';
+export * from '../components/Carousel.vue';
+export * from '../components/Checkbox.vue';
+export * from '../components/Chip.vue';
+export * from '../components/Collapsible.vue';
+export * from '../components/Drawer.vue';
+export * from '../components/DropdownMenu.vue';
+export * from '../components/FieldGroup.vue';
+export * from '../components/Form.vue';
+export * from '../components/FormField.vue';
+export * from '../components/Icon.vue';
+export * from '../components/Input.vue';
+export * from '../components/InputNumber.vue';
+export * from '../components/Kbd.vue';
+export * from '../components/Link.vue';
+export * from '../components/Modal.vue';
+export * from '../components/NavigationMenu.vue';
+export * from '../components/OverlayProvider.vue';
+export * from '../components/Pagination.vue';
+export * from '../components/PinInput.vue';
+export * from '../components/Popover.vue';
+export * from '../components/Progress.vue';
+export * from '../components/RadioGroup.vue';
+export * from '../components/ScrollArea.vue';
+export * from '../components/Select.vue';
+export * from '../components/Separator.vue';
+export * from '../components/Skeleton.vue';
+export * from '../components/Slider.vue';
+export * from '../components/Switch.vue';
+export * from '../components/Table.vue';
+export * from '../components/Tabs.vue';
+export * from '../components/Textarea.vue';
+export * from '../components/Toast.vue';
+export * from '../components/ToastProvider.vue';
+export * from '../components/Tooltip.vue';
+export * from './form';
+export * from './locale';
+export * from './style';
+export type RuntimeAppConfig = AppConfig & {
+    ui: AppConfigUI;
 };
-export type ThemeExtension = MergeThemes<typeof theme>;

package/dist/runtime/types/index.js

@@ -1,4 +1,47 @@
-export * from "./components.js";
+export * from "../components/Accordion.vue";
+export * from "../components/Alert.vue";
+export * from "../components/App.vue";
+export * from "../components/Avatar.vue";
+export * from "../components/AvatarGroup.vue";
+export * from "../components/Badge.vue";
+export * from "../components/Breadcrumb.vue";
+export * from "../components/Button.vue";
+export * from "../components/Calendar.vue";
+export * from "../components/Card.vue";
+export * from "../components/Carousel.vue";
+export * from "../components/Checkbox.vue";
+export * from "../components/Chip.vue";
+export * from "../components/Collapsible.vue";
+export * from "../components/Drawer.vue";
+export * from "../components/DropdownMenu.vue";
+export * from "../components/FieldGroup.vue";
+export * from "../components/Form.vue";
+export * from "../components/FormField.vue";
+export * from "../components/Icon.vue";
+export * from "../components/Input.vue";
+export * from "../components/InputNumber.vue";
+export * from "../components/Kbd.vue";
+export * from "../components/Link.vue";
+export * from "../components/Modal.vue";
+export * from "../components/NavigationMenu.vue";
+export * from "../components/OverlayProvider.vue";
+export * from "../components/Pagination.vue";
+export * from "../components/PinInput.vue";
+export * from "../components/Popover.vue";
+export * from "../components/Progress.vue";
+export * from "../components/RadioGroup.vue";
+export * from "../components/ScrollArea.vue";
+export * from "../components/Select.vue";
+export * from "../components/Separator.vue";
+export * from "../components/Skeleton.vue";
+export * from "../components/Slider.vue";
+export * from "../components/Switch.vue";
+export * from "../components/Table.vue";
+export * from "../components/Tabs.vue";
+export * from "../components/Textarea.vue";
+export * from "../components/Toast.vue";
+export * from "../components/ToastProvider.vue";
+export * from "../components/Tooltip.vue";
 export * from "./form.js";
 export * from "./locale.js";
-export * from "./utils.js";
+export * from "./style.js";

package/dist/runtime/types/input.d.ts

@@ -0,0 +1,8 @@
+export interface ModelModifiers {
+    string?: boolean;
+    number?: boolean;
+    trim?: boolean;
+    lazy?: boolean;
+    nullable?: boolean;
+    optional?: boolean;
+}

package/dist/runtime/types/locale.d.ts

@@ -1,3 +1,7 @@
+import type { Locale as DefineLocale, LocaleDirection } from '@byyuurin/ui-kit';
+export type DefineLocaleOptions<M> = DefineLocale<M>;
+export type Locale<M> = Required<DefineLocale<M>>;
+export type Direction = LocaleDirection;
 export interface Messages {
     alert: {
         close: string;
@@ -9,6 +13,7 @@ export interface Messages {
         nextMonth: string;
     };
     carousel: {
+        dots: string;
         prev: string;
         next: string;
         goto: string;

package/dist/runtime/types/style.d.ts

@@ -0,0 +1,33 @@
+import type { ClassProp, ClassValue, CVDefaultVariants, CVParts, CVScopeMeta, CVVariants, MaybeArray, StringToBoolean, VariantProps } from '@byyuurin/ui-kit';
+export interface ComponentBaseProps {
+    class?: ClassValue;
+}
+export type ComponentStyler<T> = T extends {
+    parts: infer P;
+    variants: infer V;
+} ? {
+    [Part in keyof P]: V extends undefined ? (props: {
+        class?: ClassValue;
+    }) => string : (props?: VariantProps<T> & {
+        class?: ClassValue;
+    }) => string;
+} : Record<string, never>;
+export type ComponentUIProps<T> = T extends {
+    parts: infer P;
+} ? {
+    [Part in keyof P]?: string;
+} : Record<string, never>;
+type UIConfigPartial<T> = {
+    [P in keyof T as T[P] extends undefined ? never : P]?: T[P] extends Array<infer V> ? V extends string ? V extends '' ? '' : string : V[] : T[P] extends object ? UIConfigPartial<T[P]> : T[P] extends string ? T[P] extends '' ? '' : string : T[P];
+};
+type PartsName<P extends CVParts, B extends ClassValue> = B extends undefined ? keyof P : keyof P | 'base';
+type PartsClassValue<S extends CVParts, B extends ClassValue> = {
+    [K in PartsName<S, B>]?: string;
+};
+type CVCompoundVariants<V extends CVVariants<P>, P extends CVParts, B extends ClassValue> = Array<{
+    [K in keyof V]?: MaybeArray<StringToBoolean<keyof V[K]>>;
+} & (P extends undefined ? ClassProp<PartsClassValue<P, B> | string> : ClassProp<PartsClassValue<P, B>>)>;
+export type UIConfig<Themes extends Record<string, any>> = {
+    [Component in keyof Themes]?: Themes[Component] extends CVScopeMeta<infer V, any, any, infer B, infer P> ? UIConfigPartial<CVScopeMeta<V, CVCompoundVariants<V, P, B>, CVDefaultVariants<V, P>, B, P>> : never;
+};
+export {};

package/dist/runtime/types/unocss.d.ts

@@ -0,0 +1,4 @@
+declare module '#build/uno-merge' {
+  const unoMerge = (code: string) => string
+  export { unoMerge }
+}

package/dist/runtime/types/utils.d.ts

@@ -1,52 +1,53 @@
-import type { ClassValue, CVReturnType, CVScopeMeta, VariantProps } from '@byyuurin/ui-kit';
-import type { AcceptableValue as RekaAcceptableValue } from 'reka-ui';
+import type { AcceptableValue as _AcceptableValue } from 'reka-ui';
+import type { VNode } from 'vue';
+export type Nullable<T> = T | null | undefined;
+export type MaybeNull<T> = T | null;
 export type MaybeArray<T> = T | T[];
-export type AcceptableValue = Exclude<RekaAcceptableValue, Record<string, any>>;
-export type EmitsToProps<T> = {
-    [K in keyof T as `on${Capitalize<string & K>}`]: T[K] extends [...args: infer Args] ? (...args: Args) => void : never;
+export type Defined<T> = Exclude<T, undefined>;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P] | undefined;
+};
+type SlotProps<T> = T extends Record<string, any> ? {
+    [P in keyof T & string]: T[P] extends undefined ? T[P] | undefined : T[P];
+} : Record<string, never>;
+export type StaticSlot<P extends Record<string, any> | undefined = undefined> = P extends Record<string, any> ? (props: SlotProps<P>) => any : (props?: SlotProps<undefined>) => any;
+export type DynamicSlotsKeys<Name extends string | undefined, Suffix extends string | undefined = undefined> = (Name extends string ? Suffix extends string ? Name | `${Name}-${Suffix}` : Name : never);
+export type DynamicSlots<T extends {
+    slot?: string;
+}, Suffix extends string | undefined = undefined, ExtraProps extends object = Record<string, never>> = {
+    [K in DynamicSlotsKeys<T['slot'], Suffix>]: StaticSlot<{
+        item: Extract<T, {
+            slot: K extends `${infer Base}-${Suffix}` ? Base : K;
+        }>;
+    } & ExtraProps>;
 };
+export type GetObjectField<MaybeObject, Key extends string> = MaybeObject extends Record<string, any> ? MaybeObject[Key] : never;
+export type AcceptableValue = Exclude<_AcceptableValue, Record<string, any>> | boolean;
+export type ArrayOrNested<T> = T[] | T[][];
+export type NestedItem<T> = T extends Array<infer I> ? NestedItem<I> : T;
 type AllKeys<T> = T extends any ? keyof T : never;
 type NonCommonKeys<T extends object> = Exclude<AllKeys<T>, keyof T>;
 type PickTypeOf<T, K extends string | number | symbol> = K extends AllKeys<T> ? T extends {
     [k in K]?: any;
 } ? T[K] : undefined : never;
 export type MergeTypes<T extends object> = {
-    [TK in keyof T]: PickTypeOf<T, TK>;
+    [k in keyof T]: PickTypeOf<T, k>;
 } & {
-    [TK in NonCommonKeys<T>]?: PickTypeOf<T, TK>;
+    [k in NonCommonKeys<T>]?: PickTypeOf<T, k>;
 };
-export type DynamicSlots<T extends {
-    slot?: string;
-}, SlotExtra extends string | undefined = undefined, SlotProps extends object = Record<string, never>> = {
-    [K in T['slot'] as K extends string ? SlotExtra extends string ? (K | `${K}-${SlotExtra}`) : K : never]?: (props: {
-        item: Extract<T, {
-            slot: K extends `${infer Base}-${SlotExtra}` ? Base : K;
-        }>;
-    } & Omit<SlotProps, 'item'>) => any;
-};
-export type ArrayOrNested<T> = T[] | T[][];
-export type NestedItem<T> = T extends Array<infer I> ? NestedItem<I> : T;
-export type GetItemKeys<T> = keyof Extract<NestedItem<T>, object>;
-export type GetItemValue<I, VK extends GetItemKeys<I> | undefined, T extends NestedItem<I> = NestedItem<I>> = T extends object ? VK extends undefined ? T : VK extends keyof T ? T[VK] : never : T;
+type DotPathKeys<T> = T extends Array<any> ? never : T extends object ? {
+    [K in keyof T & string]: T[K] extends Record<string, any> ? K | `${K}.${DotPathKeys<T[K]>}` : K;
+}[keyof T & string] : never;
+type DotPathValue<T, P extends DotPathKeys<T> | (string & {})> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? DotPathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+export type GetItemKeys<I> = keyof Extract<NestedItem<I>, object> | DotPathKeys<Extract<NestedItem<I>, object>>;
+export type GetItemValue<I, VK extends GetItemKeys<I> | undefined, T extends NestedItem<I> = NestedItem<I>> = T extends object ? VK extends undefined ? T : VK extends DotPathKeys<T> ? DotPathValue<T, VK> : never : T;
 export type GetModelValue<T, VK extends GetItemKeys<T> | undefined, M extends boolean> = M extends true ? GetItemValue<T, VK>[] : GetItemValue<T, VK>;
 export interface GetModelValueEmits<T, VK extends GetItemKeys<T> | undefined, M extends boolean> {
     /** Event handler called when the value changes. */
-    'update:modelValue': [payload: GetModelValue<T, VK, M>];
+    'update:modelValue': [value: GetModelValue<T, VK, M>];
 }
-export type GetObjectField<MaybeObject, Key extends string> = MaybeObject extends Record<string, any> ? MaybeObject[Key] : never;
-export interface ComponentAttrs<T> {
-    class?: MaybeArray<string | Record<string, boolean>>;
-    ui?: T extends {
-        parts: infer P;
-    } ? {
-        [Part in keyof P]?: string;
-    } : never;
-}
-export type StylerTheme<T> = T extends CVScopeMeta<infer V, any, any, infer B, infer S> ? CVReturnType<V, S, B> : never;
-export interface StylerBaseProps {
-    class?: ClassValue;
-}
-export type StylerProps<T> = T extends CVScopeMeta<infer V, any, any, infer B, infer S> ? Parameters<Styler<CVReturnType<V, S, B>>>[0] : never;
-export type StylerReturnType<T> = T extends CVReturnType<infer V, infer S, infer B> ? ReturnType<CVReturnType<V, S, B>> : never;
-export type Styler<T> = T extends CVReturnType<infer V, any, any> ? [keyof V] extends string[] ? (props: VariantProps<T> & StylerBaseProps) => StylerReturnType<T> : (props?: StylerBaseProps) => StylerReturnType<T> : never;
+export type StringOrVNode = string | VNode | (() => VNode);
+export type EmitsToProps<T> = {
+    [K in keyof T as `on${Capitalize<string & K>}`]: T[K] extends [...args: infer Args] ? (...args: Args) => void : never;
+};
 export {};

package/dist/runtime/utils/form.d.ts

@@ -1,5 +1,9 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { FormSchema, ValidateReturnSchema } from '../types/form.js';
+import type { Struct } from 'superstruct';
+import type { FormSchema, ValidateReturnSchema } from '../types/form';
+export declare function isSuperStructSchema(schema: any): schema is Struct<any, any>;
 export declare function isStandardSchema(schema: any): schema is StandardSchemaV1;
 export declare function validateStandardSchema(state: any, schema: StandardSchemaV1): Promise<ValidateReturnSchema<typeof state>>;
 export declare function validateSchema<T extends object>(state: T, schema: FormSchema<T>): Promise<ValidateReturnSchema<typeof state>>;
+export declare function getAtPath<T extends object>(data: T, path?: string): any;
+export declare function setAtPath<T extends object>(data: T, path: string, value: any): T;

package/dist/runtime/utils/form.js

@@ -1,3 +1,6 @@
+export function isSuperStructSchema(schema) {
+  return "schema" in schema && typeof schema.coercer === "function" && typeof schema.validator === "function" && typeof schema.refiner === "function";
+}
 export function isStandardSchema(schema) {
   return "~standard" in schema;
 }
@@ -17,8 +20,54 @@ export async function validateStandardSchema(state, schema) {
     result: result.value
   };
 }
+async function validateSuperstructSchema(state, schema) {
+  const [err, result] = schema.validate(state);
+  if (err) {
+    const errors = err.failures().map((error) => ({
+      message: error.message,
+      name: error.path.join(".")
+    }));
+    return {
+      errors,
+      result: null
+    };
+  }
+  return {
+    errors: null,
+    result
+  };
+}
 export function validateSchema(state, schema) {
   if (isStandardSchema(schema))
     return validateStandardSchema(state, schema);
+  else if (isSuperStructSchema(schema))
+    return validateSuperstructSchema(state, schema);
   throw new Error("Form validation failed: Unsupported form schema");
 }
+export function getAtPath(data, path) {
+  if (!path)
+    return data;
+  const value = path.split(".").reduce(
+    (value2, key) => value2?.[key],
+    data
+  );
+  return value;
+}
+export function setAtPath(data, path, value) {
+  if (!path)
+    return Object.assign(data, value);
+  if (!data)
+    return data;
+  const keys = path.split(".");
+  let current = data;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === void 0 || current[key] === null) {
+      current[key] = i + 1 < keys.length && !Number.isNaN(Number(keys[i + 1])) ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+  return data;
+}

package/dist/runtime/utils/index.d.ts

@@ -1,16 +1,13 @@
-import type { Messages } from '../types/index.js';
-import type { Locale } from './translator.js';
-export * from './extend-theme.js';
-export * from './form.js';
-export * from './link.js';
-export * from './styler.js';
-export * from './translator.js';
-export * from './vue.js';
+import type { GetItemKeys, Nullable } from '../types/utils';
+export * from './form';
+export * from './link';
+export * from './vue';
+export { get, omit, pick, set } from '@byyuurin/ui-kit';
 export { looseToNumber } from '@vue/shared';
-export declare function defineLocale(locale: Locale<Messages>): Locale<Messages>;
-export declare function pick<Data extends object, Keys extends keyof Data>(data: Data, keys: Keys[]): Pick<Data, Keys>;
-export declare function omit<Data extends object, Keys extends keyof Data>(data: Data, keys: Keys[]): Omit<Data, Keys>;
-export declare function get(object: Record<string, any> | undefined, path: (string | number)[] | string, defaultValue?: any): any;
-export declare function set(object: Record<string, any>, path: (string | number)[] | string, value: any): void;
 export declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+export declare function isEmpty(value: unknown): boolean;
+export declare function getDisplayValue<T extends Array<any>, V>(items: T, value: Nullable<V>, options?: {
+    valueKey?: GetItemKeys<T>;
+    labelKey?: GetItemKeys<T>;
+}): string | undefined;
 export declare function isArrayOfArray<T>(item: T[] | T[][]): item is T[][];