@xleddyl/443-components-vue 0.2.2 → 0.3.0

package/dist/composables/useForm.d.ts

@@ -1,9 +1,9 @@
-import type { ComputedRef, Ref, UnwrapRef } from 'vue';
-import type { StandardSchemaV1 } from '../internal/forms/standard-schema';
-export type { StandardSchemaIssue, StandardSchemaResult, StandardSchemaV1, } from '../internal/forms/standard-schema';
+import type { ComputedRef, MaybeRefOrGetter, Ref, UnwrapRef } from 'vue';
+import type { IssueKeyResolver, StandardSchemaIssue, StandardSchemaV1 } from '../internal/forms/standard-schema';
+export type { IssuePath as FormIssuePath, StandardSchemaIssue, StandardSchemaResult, StandardSchemaV1, } from '../internal/forms/standard-schema';
 export type FieldValidationResult = string | undefined | null | boolean;
 export interface FieldDefinition<T = unknown> {
-    initial: T | (() => T);
+    initial?: T | (() => T);
     label?: string;
     required?: boolean;
     min?: number;
@@ -37,17 +37,27 @@ export interface FormMessages {
     invalid: (context: FormMessageContext) => string;
 }
 export type FormValidationTrigger = 'submit' | 'blur' | 'input';
-export interface UseFormOptions<S extends FormSchema> {
-    schema: S;
-    validator?: StandardSchemaV1;
+export type FormIssueKey = IssueKeyResolver;
+export type FormMessageMap = Record<string, string | undefined>;
+export type FormWarningsResult = Record<string, string | undefined> | ReadonlyArray<StandardSchemaIssue> | null | undefined;
+export type FormWarningsFunction<V> = (values: V) => FormWarningsResult | Promise<FormWarningsResult>;
+export type FormWarnings<V> = StandardSchemaV1 | Readonly<Ref<StandardSchemaV1 | undefined>> | FormWarningsFunction<V>;
+export type FormPath<V> = (keyof V & string) | (string & {});
+export interface UseFormOptions<S extends FormSchema = FormSchema, V extends object = FormValues<S>> {
+    schema?: S;
+    values?: MaybeRefOrGetter<V>;
+    validator?: MaybeRefOrGetter<StandardSchemaV1 | undefined>;
+    warnings?: FormWarnings<V>;
+    issueKey?: FormIssueKey;
     messages?: Partial<FormMessages>;
     validateOn?: FormValidationTrigger;
-    onSubmit?: (values: FormValues<S>) => unknown;
+    onSubmit?: (values: V) => unknown;
     onInvalid?: (errors: FormErrors<S>) => unknown;
 }
-export type FormErrors<S extends FormSchema> = Partial<Record<keyof S & string, string>>;
+export type FormErrors<S extends FormSchema = FormSchema> = Partial<Record<keyof S & string, string>> & FormMessageMap;
 export interface FormContext {
-    errors: Readonly<Record<string, string | undefined>>;
+    errors: Readonly<FormMessageMap>;
+    warnings?: Readonly<FormMessageMap>;
     submitCount: Readonly<Ref<number>>;
     submitting: Readonly<Ref<boolean>>;
     touch: (name: string) => void;
@@ -55,26 +65,29 @@ export interface FormContext {
     submit: () => Promise<boolean>;
     reset: () => void;
 }
-export interface UseFormReturn<S extends FormSchema> extends FormContext {
+export interface UseFormReturn<S extends FormSchema = FormSchema, V extends object = FormValues<S>> extends FormContext {
     schema: S;
-    values: UnwrapRef<FormValues<S>>;
+    values: UnwrapRef<V>;
     errors: FormErrors<S>;
-    touched: Partial<Record<keyof S & string, boolean>>;
+    warnings: Readonly<FormMessageMap>;
+    rootErrors: Readonly<Ref<readonly string[]>>;
+    rootWarnings: Readonly<Ref<readonly string[]>>;
+    touched: Partial<Record<keyof V & string, boolean>> & Record<string, boolean | undefined>;
     dirty: ComputedRef<boolean>;
-    dirtyFields: ComputedRef<(keyof S & string)[]>;
+    dirtyFields: ComputedRef<(keyof V & string)[]>;
     valid: ComputedRef<boolean>;
     submitCount: Ref<number>;
     submitting: Ref<boolean>;
-    isDirty: (name: keyof S & string) => boolean;
+    isDirty: (name: keyof V & string) => boolean;
     validate: () => Promise<boolean>;
-    validateField: (name: keyof S & string) => Promise<boolean>;
-    setError: (name: keyof S & string, message: string | undefined) => void;
+    validateField: (name: keyof V & string) => Promise<boolean>;
+    setError: (name: FormPath<V>, message: string | undefined) => void;
     setErrors: (errors: FormErrors<S>) => void;
     clearErrors: () => void;
     touch: (name: string) => void;
-    reset: (values?: Partial<FormValues<S>>) => void;
+    reset: (values?: Partial<V>) => void;
     submit: () => Promise<boolean>;
 }
 export declare function isEmptyValue(value: unknown): boolean;
-export declare function useForm<S extends FormSchema>(options: UseFormOptions<S>): UseFormReturn<S>;
+export declare function useForm<S extends FormSchema = FormSchema, V extends object = FormValues<S>>(options: UseFormOptions<S, V>): UseFormReturn<S, V>;
 export declare function useFormContext(): FormContext | null;

package/dist/composables/useForm.mjs

@@ -1,5 +1,23 @@
-import { computed, inject, reactive, ref, watch } from "vue";
-import { issuesByField, runStandardSchema } from "../internal/forms/standard-schema.mjs";
+import {
+  computed,
+  inject,
+  isRef,
+  reactive,
+  readonly,
+  ref,
+  shallowRef,
+  toValue,
+  watch,
+  watchEffect
+} from "vue";
+import {
+  defaultIssueKey,
+  groupIssues,
+  isStandardSchema,
+  keyPath,
+  runStandardSchema,
+  schemaIssues
+} from "../internal/forms/standard-schema.mjs";
 import { FORM_KEY } from "../internal/keys.mjs";
 import { useLocale } from "./useLocale.mjs";
 function localeFormMessages(t) {
@@ -54,35 +72,88 @@ function measure(value) {
   if (typeof value === "string" || Array.isArray(value)) return value.length;
   return void 0;
 }
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+function settle(value, apply) {
+  if (isThenable(value)) void value.then(apply);
+  else apply(value);
+}
+function isWithin(key, name) {
+  return key === name || key.startsWith(`${name}.`);
+}
+function uniqueMessages(...lists) {
+  return [...new Set(lists.flat().filter(Boolean))];
+}
+function replaceEntries(target, next, inScope = () => true) {
+  for (const key of Object.keys(target)) {
+    if (inScope(key) && !(key in next)) delete target[key];
+  }
+  for (const [key, message] of Object.entries(next)) {
+    if (inScope(key) && target[key] !== message) target[key] = message;
+  }
+}
 export function useForm(options) {
-  const { schema } = options;
-  const names = Object.keys(schema);
+  const schema = options.schema ?? {};
+  const schemaNames = Object.keys(schema);
+  const external = options.values !== void 0;
   const { t } = useLocale();
   const messages = computed(() => ({ ...localeFormMessages(t), ...options.messages }));
   const validateOn = options.validateOn ?? "submit";
-  const initialValues = () => Object.fromEntries(names.map((name) => [name, resolveInitial(schema[name])]));
-  let baseline = initialValues();
-  const values = reactive(cloneValue(baseline));
+  const issueKey = options.issueKey ?? defaultIssueKey;
+  const initialValues = () => Object.fromEntries(schemaNames.map((name) => [name, resolveInitial(schema[name])]));
+  const internalValues = external ? void 0 : reactive(initialValues());
+  const target = () => external ? toValue(options.values) : internalValues;
+  let baseline = cloneValue(target());
+  const baselineVersion = ref(0);
+  const names = computed(() => {
+    if (!external) return schemaNames;
+    return [.../* @__PURE__ */ new Set([...schemaNames, ...Object.keys(target())])];
+  });
   const errors = reactive({});
+  const warnings = reactive({});
+  const rootErrors = shallowRef([]);
+  const rootWarnings = shallowRef([]);
   const touched = reactive({});
   const submitCount = ref(0);
   const submitting = ref(false);
-  const baselineVersion = ref(0);
-  const readValue = (name) => values[name];
+  const ruleErrors = {};
+  const manualErrors = {};
+  let issueErrors = {};
+  let issueRoot = [];
+  let manualRoot = [];
+  const readValue = (name) => target()[name];
   const dirtyFields = computed(() => {
     void baselineVersion.value;
-    return names.filter(
-      (name) => !isEqualValue(readValue(name), baseline[name])
-    );
+    const keys = external ? [.../* @__PURE__ */ new Set([...names.value, ...Object.keys(baseline)])] : names.value;
+    return keys.filter((name) => !isEqualValue(readValue(name), baseline[name]));
   });
   const dirty = computed(() => dirtyFields.value.length > 0);
-  const valid = computed(() => names.every((name) => !errors[name]));
+  const valid = computed(
+    () => !Object.values(errors).some(Boolean) && rootErrors.value.length === 0
+  );
+  function composeErrors() {
+    const next = {};
+    for (const source of [manualErrors, ruleErrors, issueErrors]) {
+      for (const [key, message] of Object.entries(source)) {
+        if (message && !(key in next)) next[key] = message;
+      }
+    }
+    return next;
+  }
+  function syncErrors(inScope) {
+    replaceEntries(errors, composeErrors(), inScope);
+    if (!inScope) rootErrors.value = uniqueMessages(manualRoot, issueRoot);
+  }
   async function runValidator() {
-    if (!options.validator) return {};
-    return issuesByField(await runStandardSchema(options.validator, cloneValue(values)));
+    const validator = toValue(options.validator);
+    if (!validator) return groupIssues([]);
+    const issues = await runStandardSchema(validator, cloneValue(target()));
+    return groupIssues(schemaIssues(issues), issueKey);
   }
-  async function runRules(name, formIssues) {
+  async function runRules(name) {
     const definition = schema[name];
+    if (!definition) return void 0;
     const value = readValue(name);
     const fieldMessages = { ...messages.value, ...definition.messages };
     const context = {
@@ -115,7 +186,7 @@ export function useForm(options) {
       }
     }
     if (definition.validate) {
-      const result = await definition.validate(value, values);
+      const result = await definition.validate(value, target());
       if (typeof result === "string" && result) return result;
       if (result === false) return fieldMessages.invalid(context);
     }
@@ -123,44 +194,108 @@ export function useForm(options) {
       const issues = await runStandardSchema(definition.schema, value);
       if (issues.length) return issues[0].message || fieldMessages.invalid(context);
     }
-    return formIssues[name];
+    return void 0;
   }
-  async function applyField(name, formIssues) {
-    const message = await runRules(name, formIssues);
-    errors[name] = message;
-    return !message;
+  function hasErrorWithin(name) {
+    return Object.entries(errors).some(([key, message]) => message && isWithin(key, name));
   }
+  let validationRun = 0;
+  const fieldRuns = /* @__PURE__ */ new Map();
   async function validateField(name) {
-    return applyField(name, await runValidator());
+    const run = (fieldRuns.get(name) ?? 0) + 1;
+    fieldRuns.set(name, run);
+    const [issues, message] = await Promise.all([runValidator(), runRules(name)]);
+    if (fieldRuns.get(name) !== run) return !message && !(name in issues.fields);
+    issueErrors = issues.fields;
+    issueRoot = issues.root;
+    ruleErrors[name] = message;
+    for (const key of Object.keys(manualErrors)) {
+      if (isWithin(key, name)) delete manualErrors[key];
+    }
+    syncErrors(submitCount.value > 0 ? void 0 : (key) => isWithin(key, name));
+    return !hasErrorWithin(name);
   }
   async function validate() {
-    const formIssues = await runValidator();
-    const results = await Promise.all(names.map((name) => applyField(name, formIssues)));
-    return results.every(Boolean);
+    const run = ++validationRun;
+    const fields = names.value;
+    const [issues, results] = await Promise.all([
+      runValidator(),
+      Promise.all(fields.map((name) => runRules(name)))
+    ]);
+    if (run === validationRun) {
+      issueErrors = issues.fields;
+      issueRoot = issues.root;
+      for (const key of Object.keys(ruleErrors)) delete ruleErrors[key];
+      fields.forEach((name, index) => ruleErrors[name] = results[index]);
+      for (const key of Object.keys(manualErrors)) delete manualErrors[key];
+      manualRoot = [];
+      syncErrors();
+    }
+    return results.every((message) => !message) && Object.keys(issues.fields).length === 0 && issues.root.length === 0;
   }
   function setError(name, message) {
-    errors[name] = message;
+    if (name === "") {
+      manualRoot = message ? [message] : [];
+      rootErrors.value = uniqueMessages(manualRoot, issueRoot);
+      return;
+    }
+    manualErrors[name] = message;
+    if (!message) {
+      delete ruleErrors[name];
+      delete issueErrors[name];
+    }
+    syncErrors((key) => key === name);
   }
   function setErrors(next) {
-    for (const name of names) errors[name] = next[name];
+    for (const key of Object.keys(manualErrors)) delete manualErrors[key];
+    for (const key of Object.keys(ruleErrors)) delete ruleErrors[key];
+    issueErrors = {};
+    for (const [key, message] of Object.entries(next)) {
+      if (key === "") manualRoot = message ? [message] : [];
+      else manualErrors[key] = message;
+    }
+    syncErrors();
   }
   function clearErrors() {
-    for (const name of names) errors[name] = void 0;
+    for (const key of Object.keys(manualErrors)) delete manualErrors[key];
+    for (const key of Object.keys(ruleErrors)) delete ruleErrors[key];
+    issueErrors = {};
+    issueRoot = [];
+    manualRoot = [];
+    syncErrors();
   }
   function touch(name) {
-    if (!(name in schema)) return;
+    const field = name.split(".")[0];
+    if (!names.value.includes(field)) return;
     touched[name] = true;
-    if (validateOn === "blur" || submitCount.value > 0) void validateField(name);
+    touched[field] = true;
+    if (validateOn === "blur" || submitCount.value > 0) void validateField(field);
   }
+  const snapshots = /* @__PURE__ */ new Map();
+  const takeSnapshots = () => {
+    snapshots.clear();
+    for (const name of names.value) snapshots.set(name, cloneValue(readValue(name)));
+  };
+  takeSnapshots();
   function reset(next) {
-    const fresh = initialValues();
-    if (next) Object.assign(fresh, cloneValue(next));
-    baseline = fresh;
+    const values = target();
+    if (external) {
+      const fresh = cloneValue(next ?? baseline);
+      for (const key of Object.keys(values)) {
+        if (!(key in fresh)) delete values[key];
+      }
+      Object.assign(values, fresh);
+      baseline = cloneValue(fresh);
+    } else {
+      const fresh = initialValues();
+      if (next) Object.assign(fresh, cloneValue(next));
+      baseline = fresh;
+      Object.assign(values, cloneValue(fresh));
+    }
     baselineVersion.value++;
-    Object.assign(values, cloneValue(fresh));
-    for (const name of names) snapshots.set(name, cloneValue(readValue(name)));
+    takeSnapshots();
     clearErrors();
-    for (const name of names) touched[name] = false;
+    for (const key of Object.keys(touched)) touched[key] = false;
     submitCount.value = 0;
   }
   async function submit() {
@@ -173,21 +308,18 @@ export function useForm(options) {
     }
     submitting.value = true;
     try {
-      await options.onSubmit?.(cloneValue(values));
+      await options.onSubmit?.(cloneValue(target()));
     } finally {
       submitting.value = false;
     }
     return true;
   }
-  const snapshots = new Map(
-    names.map((name) => [name, cloneValue(readValue(name))])
-  );
   watch(
-    () => names.map((name) => readValue(name)),
+    () => names.value.map((name) => readValue(name)),
     () => {
-      for (const name of names) {
+      for (const name of names.value) {
         const current = readValue(name);
-        if (isEqualValue(current, snapshots.get(name))) continue;
+        if (snapshots.has(name) && isEqualValue(current, snapshots.get(name))) continue;
         snapshots.set(name, cloneValue(current));
         if (validateOn === "input" || submitCount.value > 0 || validateOn === "blur" && touched[name])
           void validateField(name);
@@ -195,10 +327,45 @@ export function useForm(options) {
     },
     { deep: true }
   );
+  watch(
+    () => toValue(options.validator),
+    () => {
+      if (submitCount.value > 0) void validate();
+    }
+  );
+  const warningSource = options.warnings;
+  if (warningSource) {
+    let warningRun = 0;
+    const applyWarnings = (result) => {
+      const list = Array.isArray(result) ? schemaIssues(result) : Object.entries(result ?? {}).filter((entry) => Boolean(entry[1])).map(([key, message]) => ({ message, path: keyPath(key) }));
+      const grouped = groupIssues(list, issueKey);
+      replaceEntries(warnings, grouped.fields);
+      rootWarnings.value = grouped.root;
+    };
+    const evaluate = () => {
+      if (typeof warningSource === "function") return warningSource(target());
+      const schemaSource = isRef(warningSource) ? warningSource.value : warningSource;
+      if (!schemaSource || !isStandardSchema(schemaSource)) return void 0;
+      const result = schemaSource["~standard"].validate(cloneValue(target()));
+      const issuesOf = (outcome) => outcome.issues ?? [];
+      return isThenable(result) ? result.then(issuesOf) : issuesOf(result);
+    };
+    watchEffect(() => {
+      const run = ++warningRun;
+      settle(evaluate(), (result) => {
+        if (run === warningRun) applyWarnings(result);
+      });
+    });
+  }
   return {
     schema,
-    values,
+    get values() {
+      return target();
+    },
     errors,
+    warnings: readonly(warnings),
+    rootErrors,
+    rootWarnings,
     touched,
     dirty,
     dirtyFields,

package/dist/editor/RichTextEditor.vue

@@ -117,6 +117,8 @@ const props = defineProps({
   maxHeight: { type: String, required: false },
   label: { type: String, required: false },
   headings: { type: Array, required: false, default: () => [2, 3, 4] },
+  headingLabel: { type: String, required: false, default: "level" },
+  toolbar: { type: Array, required: false },
   extensions: { type: Array, required: false, default: () => [] },
   messages: { type: Object, required: false }
 });
@@ -207,7 +209,8 @@ watch(
   () => editor.value?.setOptions({ editorProps: { attributes: contentAttributes() } })
 );
 onBeforeUnmount(() => editor.value?.destroy());
-function heading(level, rank) {
+function heading(level, index) {
+  const rank = props.headingLabel === "relative" ? index + 1 : level;
   return {
     id: `h${level}`,
     label: formatLocaleMessage(locale.value.code, text.value.heading, { level: rank }),
@@ -227,7 +230,7 @@ function mark(id, label, glyph, glyphClass, name, toggle) {
     run: toggle
   };
 }
-const groups = computed(() => [
+const defaultToolbar = computed(() => [
   [
     {
       id: "undo",
@@ -246,7 +249,7 @@ const groups = computed(() => [
       run: () => editor.value?.chain().focus().redo().run()
     }
   ],
-  props.headings.map((level, index) => heading(level, index + 1)),
+  props.headings.map((level, index) => heading(level, index)),
   [
     mark(
       "bold",
@@ -314,6 +317,30 @@ const groups = computed(() => [
     }
   ]
 ]);
+function isToolbarGroups(toolbar) {
+  return toolbar.some((entry) => Array.isArray(entry));
+}
+function splitToolbar(toolbar) {
+  if (isToolbarGroups(toolbar)) return toolbar;
+  const result = [[]];
+  for (const entry of toolbar) {
+    if (entry === "|") result.push([]);
+    else result[result.length - 1].push(entry);
+  }
+  return result;
+}
+const groups = computed(() => {
+  if (!props.toolbar) return defaultToolbar.value.filter((group) => group.length);
+  const byId = new Map(defaultToolbar.value.flat().map((item) => [item.id, item]));
+  const headingItems = defaultToolbar.value[1] ?? [];
+  return splitToolbar(props.toolbar).map(
+    (group) => group.flatMap((entry) => {
+      if (entry === "headings") return headingItems;
+      const item = byId.get(entry);
+      return item ? [item] : [];
+    })
+  ).filter((group) => group.length);
+});
 function itemAttributes(item) {
   const disabled = item.enabled ? !item.enabled() : false;
   return {

package/dist/editor/RichTextEditor.vue.d.ts

@@ -1,6 +1,6 @@
 import type { Editor } from '@tiptap/vue-3';
 import type { Extensions } from '@tiptap/vue-3';
-import type { EditorFormat, EditorHeadingLevel, EditorMessages, EditorValue } from './types';
+import type { EditorFormat, EditorHeadingLabel, EditorHeadingLevel, EditorMessages, EditorToolbar, EditorValue } from './types';
 declare const __VLS_export: import("vue").DefineComponent<{
     format?: EditorFormat;
     placeholder?: string | undefined;
@@ -14,6 +14,8 @@ declare const __VLS_export: import("vue").DefineComponent<{
     maxHeight?: string;
     label?: string;
     headings?: EditorHeadingLevel[];
+    headingLabel?: EditorHeadingLabel;
+    toolbar?: EditorToolbar;
     extensions?: Extensions;
     messages?: Partial<EditorMessages>;
     modelValue?: EditorValue;
@@ -22,7 +24,6 @@ declare const __VLS_export: import("vue").DefineComponent<{
     title?: string | undefined | undefined;
     style?: import("vue").StyleValue;
     results?: (string | number) | undefined;
-    ref?: import("vue").VNodeRef | undefined;
     class?: import("vue").ClassValue;
     role?: string | undefined | undefined;
     'aria-label'?: string | undefined | undefined;
@@ -135,7 +136,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;
@@ -172,6 +173,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-valuemin'?: (string | number) | undefined;
     'aria-valuenow'?: (string | number) | undefined;
     'aria-valuetext'?: string | undefined | undefined;
+    ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
     accesskey?: string | undefined | undefined;
@@ -226,6 +228,8 @@ declare const __VLS_export: import("vue").DefineComponent<{
     maxHeight?: string;
     label?: string;
     headings?: EditorHeadingLevel[];
+    headingLabel?: EditorHeadingLabel;
+    toolbar?: EditorToolbar;
     extensions?: Extensions;
     messages?: Partial<EditorMessages>;
     modelValue?: EditorValue;
@@ -234,7 +238,6 @@ declare const __VLS_export: import("vue").DefineComponent<{
     title?: string | undefined | undefined;
     style?: import("vue").StyleValue;
     results?: (string | number) | undefined;
-    ref?: import("vue").VNodeRef | undefined;
     class?: import("vue").ClassValue;
     role?: string | undefined | undefined;
     'aria-label'?: string | undefined | undefined;
@@ -347,7 +350,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;
@@ -384,6 +387,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-valuemin'?: (string | number) | undefined;
     'aria-valuenow'?: (string | number) | undefined;
     'aria-valuetext'?: string | undefined | undefined;
+    ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
     accesskey?: string | undefined | undefined;
@@ -425,8 +429,9 @@ declare const __VLS_export: import("vue").DefineComponent<{
 }>, {
     invalid: boolean;
     format: EditorFormat;
-    minHeight: string;
     headings: EditorHeadingLevel[];
+    minHeight: string;
+    headingLabel: EditorHeadingLabel;
     extensions: Extensions;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/editor/rich-text-editor.css

@@ -95,7 +95,7 @@
 
 .k-editor-glyph-text.is-mono {
    font-family: var(--k-font-mono);
-   font-size: 0.6875rem;
+   font-size: 0.75rem;
 }
 
 .k-editor-glyph-text.is-tabular {

package/dist/editor/types.d.ts

@@ -4,3 +4,6 @@ export type EditorFormat = 'html' | 'json';
 export type EditorValue = string | JSONContent | null;
 export type EditorMessages = KMessages['editor'];
 export type EditorHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type EditorHeadingLabel = 'level' | 'relative';
+export type EditorToolbarItem = 'undo' | 'redo' | 'headings' | `h${EditorHeadingLevel}` | 'bold' | 'italic' | 'strike' | 'code' | 'bulletList' | 'orderedList' | 'blockquote' | 'link' | '|';
+export type EditorToolbar = EditorToolbarItem[] | EditorToolbarItem[][];

package/dist/grid/GridToolbar.vue.d.ts

@@ -18,7 +18,6 @@ declare const __VLS_base: import("vue").DefineComponent<{
     style?: import("vue").StyleValue;
     results?: (string | number) | undefined;
     placeholder?: string | undefined | undefined;
-    ref?: import("vue").VNodeRef | undefined;
     class?: import("vue").ClassValue;
     role?: string | undefined | undefined;
     'aria-label'?: string | undefined | undefined;
@@ -131,7 +130,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;
@@ -168,6 +167,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     'aria-valuemin'?: (string | number) | undefined;
     'aria-valuenow'?: (string | number) | undefined;
     'aria-valuetext'?: string | undefined | undefined;
+    ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
     accesskey?: string | undefined | undefined;
@@ -222,7 +222,6 @@ declare const __VLS_base: import("vue").DefineComponent<{
     style?: import("vue").StyleValue;
     results?: (string | number) | undefined;
     placeholder?: string | undefined | undefined;
-    ref?: import("vue").VNodeRef | undefined;
     class?: import("vue").ClassValue;
     role?: string | undefined | undefined;
     'aria-label'?: string | undefined | undefined;
@@ -335,7 +334,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;
@@ -372,6 +371,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     'aria-valuemin'?: (string | number) | undefined;
     'aria-valuenow'?: (string | number) | undefined;
     'aria-valuetext'?: string | undefined | undefined;
+    ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
     accesskey?: string | undefined | undefined;

package/dist/grid/cells/BadgeCell.vue.d.ts

@@ -56,7 +56,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;
@@ -250,7 +250,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     'aria-colindex'?: (string | number) | undefined;
     'aria-colspan'?: (string | number) | undefined;
     'aria-controls'?: string | undefined | undefined;
-    'aria-current'?: "page" | "location" | "time" | (boolean | "true" | "false") | "step" | "date" | undefined;
+    'aria-current'?: "page" | "time" | (boolean | "true" | "false") | "step" | "location" | "date" | undefined;
     'aria-describedby'?: string | undefined | undefined;
     'aria-details'?: string | undefined | undefined;
     'aria-disabled'?: (boolean | "true" | "false") | undefined;