@bitrix24/b24ui-nuxt 0.1.1

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

@@ -0,0 +1,84 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ComputedRef, DeepReadonly, Ref } from 'vue';
+import type { ZodSchema } from 'zod';
+import type { Schema as JoiSchema } from 'joi';
+import type { ObjectSchema as YupObjectSchema } from 'yup';
+import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
+import type { GetObjectField } from './utils';
+import type { Struct as SuperstructSchema } from 'superstruct';
+export interface Form<T extends object> {
+    validate(opts?: {
+        name?: keyof T | (keyof T)[];
+        silent?: boolean;
+        nested?: boolean;
+        transform?: boolean;
+    }): Promise<T | false>;
+    clear(path?: string): void;
+    errors: Ref<FormError[]>;
+    setErrors(errs: FormError[], name?: keyof T): void;
+    getErrors(name?: keyof T): FormError[];
+    submit(): Promise<void>;
+    disabled: ComputedRef<boolean>;
+    dirty: ComputedRef<boolean>;
+    dirtyFields: DeepReadonly<Set<keyof T>>;
+    touchedFields: DeepReadonly<Set<keyof T>>;
+    blurredFields: DeepReadonly<Set<keyof T>>;
+}
+export type FormSchema<T extends object> = ZodSchema | YupObjectSchema<T> | ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any> | JoiSchema<T> | SuperstructSchema<any, any> | StandardSchemaV1;
+export type FormInputEvents = 'input' | 'blur' | 'change' | 'focus';
+export interface FormError<P extends string = string> {
+    name: P;
+    message: string;
+}
+export interface FormErrorWithId extends FormError {
+    id?: string;
+}
+export type FormSubmitEvent<T> = SubmitEvent & {
+    data: T;
+};
+export type FormValidationError = {
+    errors: FormErrorWithId[];
+    children?: FormValidationError[];
+};
+export type FormErrorEvent = SubmitEvent & FormValidationError;
+export type FormEventType = FormInputEvents;
+export type FormChildAttachEvent = {
+    type: 'attach';
+    formId: string | number;
+    validate: Form<any>['validate'];
+};
+export type FormChildDetachEvent = {
+    type: 'detach';
+    formId: string | number;
+};
+export type FormInputEvent<T extends object> = {
+    type: FormEventType;
+    name: keyof T;
+    eager?: boolean;
+};
+export type FormEvent<T extends object> = FormInputEvent<T> | FormChildAttachEvent | 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;
+    ariaId: string;
+}
+export interface ValidateReturnSchema<T> {
+    result: T;
+    errors: FormError[] | null;
+}
+export declare class FormValidationException extends Error {
+    formId: string | number;
+    errors: FormErrorWithId[];
+    children?: FormValidationException[];
+    constructor(formId: string | number, errors: FormErrorWithId[], childErrors?: FormValidationException[]);
+}

package/dist/runtime/types/form.js

@@ -0,0 +1,12 @@
+export class FormValidationException extends Error {
+  formId;
+  errors;
+  children;
+  constructor(formId, errors, childErrors) {
+    super("Form validation exception");
+    this.formId = formId;
+    this.errors = errors;
+    this.children = childErrors;
+    Object.setPrototypeOf(this, FormValidationException.prototype);
+  }
+}

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

@@ -0,0 +1,3 @@
+import type { FunctionalComponent, HTMLAttributes, VNodeProps } from 'vue';
+export interface IconComponent extends FunctionalComponent<HTMLAttributes & VNodeProps, {}, any, {}> {
+}

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

@@ -0,0 +1,33 @@
+export * from '../components/Advice.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/Button.vue';
+export * from '../components/ButtonGroup.vue';
+export * from '../components/Checkbox.vue';
+export * from '../components/Chip.vue';
+export * from '../components/Container.vue';
+export * from '../components/Countdown.vue';
+export * from '../components/Form.vue';
+export * from '../components/FormField.vue';
+export * from '../components/Input.vue';
+export * from '../components/Kbd.vue';
+export * from '../components/Link.vue';
+export * from '../components/Progress.vue';
+export * from '../components/RadioGroup.vue';
+export * from '../components/Range.vue';
+export * from '../components/Select.vue';
+export * from '../components/Separator.vue';
+export * from '../components/Skeleton.vue';
+export * from '../components/Switch.vue';
+export * from '../components/Tabs.vue';
+export * from '../components/Textarea.vue';
+export * from '../components/Toast.vue';
+export * from '../components/Toaster.vue';
+export * from '../components/Tooltip.vue';
+export * from '../components/content/DescriptionList.vue';
+export * from './form';
+export * from './locale';
+export * from './icons';

package/dist/runtime/types/index.js

@@ -0,0 +1,33 @@
+export * from "../components/Advice.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/Button.vue";
+export * from "../components/ButtonGroup.vue";
+export * from "../components/Checkbox.vue";
+export * from "../components/Chip.vue";
+export * from "../components/Container.vue";
+export * from "../components/Countdown.vue";
+export * from "../components/Form.vue";
+export * from "../components/FormField.vue";
+export * from "../components/Input.vue";
+export * from "../components/Kbd.vue";
+export * from "../components/Link.vue";
+export * from "../components/Progress.vue";
+export * from "../components/RadioGroup.vue";
+export * from "../components/Range.vue";
+export * from "../components/Select.vue";
+export * from "../components/Separator.vue";
+export * from "../components/Skeleton.vue";
+export * from "../components/Switch.vue";
+export * from "../components/Tabs.vue";
+export * from "../components/Textarea.vue";
+export * from "../components/Toast.vue";
+export * from "../components/Toaster.vue";
+export * from "../components/Tooltip.vue";
+export * from "../components/content/DescriptionList.vue";
+export * from "./form.js";
+export * from "./locale.js";
+export * from "./icons.js";

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

@@ -0,0 +1,50 @@
+export type Messages = {
+    inputMenu: {
+        noMatch: string;
+        noData: string;
+        create: string;
+    };
+    inputNumber: {
+        increment: string;
+        decrement: string;
+    };
+    commandPalette: {
+        placeholder: string;
+        noMatch: string;
+        noData: string;
+        close: string;
+    };
+    selectMenu: {
+        noMatch: string;
+        noData: string;
+        create: string;
+        search: string;
+    };
+    toast: {
+        close: string;
+    };
+    carousel: {
+        prev: string;
+        next: string;
+        goto: string;
+    };
+    modal: {
+        close: string;
+    };
+    slideover: {
+        close: string;
+    };
+    alert: {
+        close: string;
+    };
+    table: {
+        noData: string;
+    };
+};
+export type Direction = 'ltr' | 'rtl';
+export type Locale = {
+    name: string;
+    code: string;
+    dir: Direction;
+    messages: Messages;
+};

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

@@ -0,0 +1,22 @@
+export interface TightMap<O = any> {
+    [key: string]: TightMap | O;
+}
+export type DeepPartial<T, O = any> = {
+    [P in keyof T]?: T[P] extends Array<string> ? string : T[P] extends object ? DeepPartial<T[P], O> : T[P];
+} & {
+    [key: string]: O | TightMap<O>;
+};
+export type DynamicSlots<T extends {
+    slot?: string;
+}, SlotProps, Slot = T['slot']> = Record<string, SlotProps> & (Slot extends string ? Record<Slot, SlotProps> : Record<string, never>);
+export type GetObjectField<MaybeObject, Key extends string> = MaybeObject extends Record<string, any> ? MaybeObject[Key] : never;
+export type PartialString<T> = {
+    [K in keyof T]?: string;
+};
+export type MaybeArrayOfArray<T> = T[] | T[][];
+export type MaybeArrayOfArrayItem<I> = I extends Array<infer T> ? T extends Array<infer U> ? U : T : never;
+export type SelectModelValue<T, V, M extends boolean = false, DV = T> = (T extends Record<string, any> ? V extends keyof T ? T[V] : DV : T) extends infer U ? M extends true ? U[] : U : never;
+export type SelectItemKey<T> = T extends Record<string, any> ? keyof T : string;
+export type SelectModelValueEmits<T, V, M extends boolean = false, DV = T> = {
+    'update:modelValue': [payload: SelectModelValue<T, V, M, DV>];
+};

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

@@ -0,0 +1,17 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ZodSchema } from 'zod';
+import type { ValidationError as JoiError, Schema as JoiSchema } from 'joi';
+import type { ObjectSchema as YupObjectSchema, ValidationError as YupError } from 'yup';
+import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
+import type { Struct } from 'superstruct';
+import type { FormSchema, ValidateReturnSchema } from '../types/form';
+export declare function isYupSchema(schema: any): schema is YupObjectSchema<any>;
+export declare function isYupError(error: any): error is YupError;
+export declare function isSuperStructSchema(schema: any): schema is Struct<any, any>;
+export declare function isZodSchema(schema: any): schema is ZodSchema;
+export declare function isJoiSchema(schema: any): schema is JoiSchema;
+export declare function isJoiError(error: any): error is JoiError;
+export declare function isValibotSchema(schema: any): schema is ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<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>>;

package/dist/runtime/utils/form.js

@@ -0,0 +1,153 @@
+export function isYupSchema(schema) {
+  return schema.validate && schema.__isYupSchema__;
+}
+export function isYupError(error) {
+  return error.inner !== void 0;
+}
+export function isSuperStructSchema(schema) {
+  return "schema" in schema && typeof schema.coercer === "function" && typeof schema.validator === "function" && typeof schema.refiner === "function";
+}
+export function isZodSchema(schema) {
+  return schema.parse !== void 0;
+}
+export function isJoiSchema(schema) {
+  return schema.validateAsync !== void 0 && schema.id !== void 0;
+}
+export function isJoiError(error) {
+  return error.isJoi === true;
+}
+export function isValibotSchema(schema) {
+  return "_run" in schema || typeof schema === "function" && "schema" in schema;
+}
+export function isStandardSchema(schema) {
+  return "~standard" in schema;
+}
+export async function validateStandardSchema(state, schema) {
+  const result = await schema["~standard"].validate(state);
+  if (result.issues) {
+    return {
+      errors: result.issues?.map((issue) => ({
+        name: issue.path?.map((item) => typeof item === "object" ? item.key : item).join(".") || "",
+        message: issue.message
+      })) || [],
+      result: null
+    };
+  }
+  return {
+    errors: null,
+    result: result.value
+  };
+}
+async function validateYupSchema(state, schema) {
+  try {
+    const result = await schema.validate(state, { abortEarly: false });
+    return {
+      errors: null,
+      result
+    };
+  } catch (error) {
+    if (isYupError(error)) {
+      const errors = error.inner.map((issue) => ({
+        name: issue.path ?? "",
+        message: issue.message
+      }));
+      return {
+        errors,
+        result: null
+      };
+    } else {
+      throw error;
+    }
+  }
+}
+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
+  };
+}
+async function validateZodSchema(state, schema) {
+  const result = await schema.safeParseAsync(state);
+  if (result.success === false) {
+    const errors = result.error.issues.map((issue) => ({
+      name: issue.path.join("."),
+      message: issue.message
+    }));
+    return {
+      errors,
+      result: null
+    };
+  }
+  return {
+    result: result.data,
+    errors: null
+  };
+}
+async function validateJoiSchema(state, schema) {
+  try {
+    const result = await schema.validateAsync(state, { abortEarly: false });
+    return {
+      errors: null,
+      result
+    };
+  } catch (error) {
+    if (isJoiError(error)) {
+      const errors = error.details.map((issue) => ({
+        name: issue.path.join("."),
+        message: issue.message
+      }));
+      return {
+        errors,
+        result: null
+      };
+    } else {
+      throw error;
+    }
+  }
+}
+async function validateValibotSchema(state, schema) {
+  const result = await ("_run" in schema ? schema._run({ typed: false, value: state }, {}) : schema(state));
+  if (!result.issues || result.issues.length === 0) {
+    const output = "output" in result ? result.output : "value" in result ? result.value : null;
+    return {
+      errors: null,
+      result: output
+    };
+  }
+  const errors = result.issues.map((issue) => ({
+    name: issue.path?.map((item) => item.key).join(".") || "",
+    message: issue.message
+  }));
+  return {
+    errors,
+    result: null
+  };
+}
+export function validateSchema(state, schema) {
+  if (isZodSchema(schema)) {
+    return validateZodSchema(state, schema);
+  } else if (isJoiSchema(schema)) {
+    return validateJoiSchema(state, schema);
+  } else if (isStandardSchema(schema)) {
+    return validateStandardSchema(state, schema);
+  } else if (isValibotSchema(schema)) {
+    return validateValibotSchema(state, schema);
+  } else if (isYupSchema(schema)) {
+    return validateYupSchema(state, schema);
+  } else if (isSuperStructSchema(schema)) {
+    return validateSuperstructSchema(state, schema);
+  } else {
+    throw new Error("Form validation failed: Unsupported form schema");
+  }
+}

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

@@ -0,0 +1,4 @@
+import type { FuseResult } from 'fuse.js';
+export declare function highlight<T>(item: T & {
+    matches?: FuseResult<T>['matches'];
+}, searchTerm: string, forceKey?: string, omitKeys?: string[]): string | undefined;

package/dist/runtime/utils/fuse.js

@@ -0,0 +1,63 @@
+function truncateHTMLFromStart(html, maxLength) {
+  let truncated = "";
+  let totalLength = 0;
+  let insideTag = false;
+  for (let i = html.length - 1; i >= 0; i--) {
+    if (html[i] === ">") {
+      insideTag = true;
+    } else if (html[i] === "<") {
+      insideTag = false;
+      truncated = html[i] + truncated;
+      continue;
+    }
+    if (!insideTag) {
+      totalLength++;
+    }
+    if (totalLength <= maxLength) {
+      truncated = html[i] + truncated;
+    } else {
+      truncated = "..." + truncated;
+      break;
+    }
+  }
+  return truncated;
+}
+export function highlight(item, searchTerm, forceKey, omitKeys) {
+  function generateHighlightedText(value, indices = []) {
+    value = value || "";
+    let content = "";
+    let nextUnhighlightedRegionStartingIndex = 0;
+    indices.forEach((region) => {
+      if (region.length === 2 && region[0] === region[1]) {
+        return;
+      }
+      const lastIndiceNextIndex = region[1] + 1;
+      const isMatched = lastIndiceNextIndex - region[0] >= searchTerm.length;
+      content += [
+        value.substring(nextUnhighlightedRegionStartingIndex, region[0]),
+        isMatched && `<mark>`,
+        value.substring(region[0], lastIndiceNextIndex),
+        isMatched && "</mark>"
+      ].filter(Boolean).join("");
+      nextUnhighlightedRegionStartingIndex = lastIndiceNextIndex;
+    });
+    content += value.substring(nextUnhighlightedRegionStartingIndex);
+    const markIndex = content.indexOf("<mark>");
+    if (markIndex !== -1) {
+      content = truncateHTMLFromStart(content, content.length - markIndex);
+    }
+    return content;
+  }
+  if (!item.matches?.length) {
+    return;
+  }
+  for (const match of item.matches) {
+    if (forceKey && match.key !== forceKey) {
+      continue;
+    }
+    if (omitKeys?.includes(match.key)) {
+      continue;
+    }
+    return generateHighlightedText(match.value, match.indices);
+  }
+}

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

@@ -0,0 +1,6 @@
+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 looseToNumber(val: any): any;
+export declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;

package/dist/runtime/utils/index.js

@@ -0,0 +1,63 @@
+import { isEqual } from "ohash";
+export function pick(data, keys) {
+  const result = {};
+  for (const key of keys) {
+    result[key] = data[key];
+  }
+  return result;
+}
+export function omit(data, keys) {
+  const result = { ...data };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+export function get(object, path, defaultValue) {
+  if (typeof path === "string") {
+    path = path.split(".").map((key) => {
+      const numKey = Number(key);
+      return Number.isNaN(numKey) ? key : numKey;
+    });
+  }
+  let result = object;
+  for (const key of path) {
+    if (result === void 0 || result === null) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result !== void 0 ? result : defaultValue;
+}
+export function set(object, path, value) {
+  if (typeof path === "string") {
+    path = path.split(".").map((key) => {
+      const numKey = Number(key);
+      return Number.isNaN(numKey) ? key : numKey;
+    });
+  }
+  path.reduce((acc, key, i) => {
+    if (acc[key] === void 0) acc[key] = {};
+    if (i === path.length - 1) acc[key] = value;
+    return acc[key];
+  }, object);
+}
+export function looseToNumber(val) {
+  const n = Number.parseFloat(val);
+  return Number.isNaN(n) ? val : n;
+}
+export function compare(value, currentValue, comparator) {
+  if (value === void 0 || currentValue === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value === currentValue;
+  }
+  if (typeof comparator === "function") {
+    return comparator(value, currentValue);
+  }
+  if (typeof comparator === "string") {
+    return get(value, comparator) === get(currentValue, comparator);
+  }
+  return isEqual(value, currentValue);
+}

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

@@ -0,0 +1,29 @@
+import type { LinkProps } from '../types';
+export declare function pickLinkProps(link: LinkProps & {
+    ariaLabel?: string;
+    title?: string;
+}): {
+    replace: any;
+    type: any;
+    title: any;
+    exact: any;
+    active: any;
+    activeClass: any;
+    ariaCurrentValue: any;
+    ariaLabel: any;
+    as: any;
+    disabled: any;
+    exactActiveClass: any;
+    exactHash: any;
+    exactQuery: any;
+    external: any;
+    href: any;
+    inactiveClass: any;
+    noPrefetch: any;
+    noRel: any;
+    prefetch: any;
+    prefetchedClass: any;
+    rel: any;
+    target: any;
+    to: any;
+};

package/dist/runtime/utils/link.js

@@ -0,0 +1,4 @@
+import { reactivePick } from "@vueuse/core";
+export function pickLinkProps(link) {
+  return reactivePick(link, "active", "activeClass", "ariaCurrentValue", "ariaLabel", "as", "disabled", "exact", "exactActiveClass", "exactHash", "exactQuery", "external", "href", "inactiveClass", "noPrefetch", "noRel", "prefetch", "prefetchedClass", "rel", "replace", "target", "to", "type", "title");
+}

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

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import type { Locale, Direction } from '../types/locale';
+import type { MaybeRef } from '@vueuse/core';
+export type TranslatorOption = Record<string, string | number>;
+export type Translator = (path: string, option?: TranslatorOption) => string;
+export type LocaleContext = {
+    locale: Ref<Locale>;
+    lang: Ref<string>;
+    dir: Ref<Direction>;
+    code: Ref<string>;
+    t: Translator;
+};
+export declare function buildTranslator(locale: MaybeRef<Locale>): Translator;
+export declare function translate(path: string, option: undefined | TranslatorOption, locale: Locale): string;
+export declare function buildLocaleContext(locale: MaybeRef<Locale>): LocaleContext;

package/dist/runtime/utils/locale.js

@@ -0,0 +1,25 @@
+import { computed, isRef, ref, unref } from "vue";
+import { get } from "./index.js";
+export function buildTranslator(locale) {
+  return (path, option) => translate(path, option, unref(locale));
+}
+export function translate(path, option, locale) {
+  const prop = get(locale, `messages.${path}`, path);
+  return prop.replace(
+    /\{(\w+)\}/g,
+    (_, key) => `${option?.[key] ?? `{${key}}`}`
+  );
+}
+export function buildLocaleContext(locale) {
+  const lang = computed(() => unref(locale).name);
+  const code = computed(() => unref(locale).code);
+  const dir = computed(() => unref(locale).dir);
+  const localeRef = isRef(locale) ? locale : ref(locale);
+  return {
+    lang,
+    code,
+    dir,
+    locale: localeRef,
+    t: buildTranslator(locale)
+  };
+}

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

@@ -0,0 +1 @@
+export declare const tv: import("tailwind-variants").CreateTV<boolean | (string | number | symbol)[] | {} | undefined>;

package/dist/runtime/utils/tv.js

@@ -0,0 +1,4 @@
+import { createTV } from "tailwind-variants";
+import _appConfig from "#build/app.config";
+const appConfigTv = _appConfig;
+export const tv = createTV(appConfigTv.b24ui?.tv);