nuxt-ui-tools 0.1.0

package/dist/runtime/form/fields/array-table/component.vue

@@ -0,0 +1,335 @@
+<script setup>
+import UButton from "@nuxt/ui/components/Button.vue";
+import { computed, defineAsyncComponent } from "vue";
+import FormFieldRenderer from "../../components/renderer/FormFieldRenderer.vue";
+import { useFormRuntimeContext } from "../../composables/use-form-runtime";
+import { useFormUi } from "../../composables/use-form-ui";
+import { syncFormArrayItems } from "../../utils/array";
+import { buildInitialFormFieldsState } from "../../utils/state";
+import { resolveFormText } from "../../utils/text";
+import { mergeFormUiClass } from "../../utils/ui";
+const props = defineProps({
+  field: { type: Object, required: true },
+  path: { type: Array, required: true }
+});
+const VueDraggable = defineAsyncComponent(
+  () => import("vue-draggable-plus").then(({ VueDraggable: draggableComponent }) => draggableComponent)
+);
+const form = useFormRuntimeContext();
+const formUi = useFormUi();
+const itemKeys = /* @__PURE__ */ new WeakMap();
+let nextItemKey = 0;
+const items = computed(() => {
+  const value = form.getValue(props.path);
+  return Array.isArray(value) ? value.filter(isFormObject) : [];
+});
+const columns = computed(
+  () => props.field.fields.filter((field) => field.type !== "hidden" && field.ignore !== true)
+);
+const minWidth = computed(
+  () => typeof props.field.minWidth === "number" ? `${props.field.minWidth}px` : props.field.minWidth
+);
+const canAdd = computed(() => resolveAction(props.field.actions?.addItem, -1));
+const isDraggable = computed(() => props.field.draggable === true);
+const dragItems = computed({
+  get: () => [...items.value],
+  set: updateItems
+});
+function addItem() {
+  const index = items.value.length;
+  let item = buildInitialFormFieldsState(props.field.fields, form.context);
+  item = applyVirtualFields(item, index);
+  if (props.field.transformOnCreate)
+    item = props.field.transformOnCreate(item, index, actionParams(index).deps);
+  updateItems([...items.value, item]);
+}
+function removeItem(index) {
+  const message = typeof props.field.confirmDelete === "string" || typeof props.field.confirmDelete === "function" ? resolveFormText(props.field.confirmDelete) : "Remove this row?";
+  if (props.field.confirmDelete && !window.confirm(message)) return;
+  updateItems(items.value.filter((_, itemIndex) => itemIndex !== index));
+}
+function moveItem(index, direction) {
+  const target = index + direction;
+  if (target < 0 || target >= items.value.length) return;
+  const current = items.value[index];
+  const next = items.value[target];
+  if (!current || !next) return;
+  const values = [...items.value];
+  values[index] = next;
+  values[target] = current;
+  updateItems(values);
+}
+function updateItems(value) {
+  const current = form.getValue(props.path);
+  if (!syncFormArrayItems(current, value)) {
+    form.setValue(
+      props.path,
+      value.map((item, index) => applyVirtualFields(item, index))
+    );
+    return;
+  }
+  if (Array.isArray(current))
+    current.forEach((item, index) => {
+      if (isFormObject(item)) applyVirtualFields(item, index);
+    });
+}
+function applyVirtualFields(item, index) {
+  if (!props.field.virtualFields) return item;
+  for (const [key, resolver] of Object.entries(props.field.virtualFields))
+    item[key] = resolver(index);
+  return item;
+}
+function resolveAction(condition, index) {
+  if (typeof condition === "boolean") return condition;
+  if (typeof condition !== "function") return true;
+  const item = items.value[index] ?? {};
+  return condition(actionParams(index));
+}
+async function runCustomAction(index, actionIndex) {
+  const action = props.field.actions?.custom?.[actionIndex];
+  const item = items.value[index];
+  if (!action || !item) return;
+  await action.action(actionParams(index));
+}
+function customActionVisible(index, actionIndex) {
+  const action = props.field.actions?.custom?.[actionIndex];
+  const item = items.value[index];
+  if (!action || !item) return false;
+  return action.condition?.(actionParams(index)) ?? true;
+}
+function hasRowActions(index) {
+  return isDraggable.value || resolveAction(props.field.actions?.deleteItem, index) || resolveAction(props.field.actions?.moveUp, index) || resolveAction(props.field.actions?.moveDown, index) || Boolean(
+    props.field.actions?.custom?.some(
+      (_action, actionIndex) => customActionVisible(index, actionIndex)
+    )
+  );
+}
+const showActionsColumn = computed(
+  () => items.value.some((_item, index) => hasRowActions(index))
+);
+function rowPath(index) {
+  return [...props.path, String(index)];
+}
+function itemKey(item) {
+  const existing = itemKeys.get(item);
+  if (existing) return existing;
+  nextItemKey += 1;
+  const key = `array-table-item-${nextItemKey}`;
+  itemKeys.set(item, key);
+  return key;
+}
+function itemRenderKey(item, index) {
+  return `${itemKey(item)}:${index}`;
+}
+function actionParams(index) {
+  const item = items.value[index] ?? {};
+  const callback = form.getFieldCallbackParams(props.path, props.field);
+  return {
+    index,
+    item,
+    items: items.value,
+    ctx: callback.ctx,
+    deps: callback.deps,
+    getValue: (key) => form.getValue([...rowPath(index), ...key.split(".")]),
+    setValue: (key, value) => form.setValue([...rowPath(index), ...key.split(".")], value),
+    getOptions: (key) => form.getFieldApi([...rowPath(index), ...key.split(".")]).options.get()
+  };
+}
+function isFormObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fieldLabel(field) {
+  return "label" in field ? resolveFormText(field.label) ?? field.key : field.key;
+}
+</script>
+
+<template>
+  <section :class="mergeFormUiClass('grid gap-3', formUi.ui.value.arrayTable?.ui?.root)">
+    <div
+      :class="
+  mergeFormUiClass(
+    'w-full overflow-x-auto rounded-lg border border-default bg-default',
+    formUi.ui.value.arrayTable?.ui?.viewport
+  )
+"
+    >
+      <table
+        :class="
+  mergeFormUiClass(
+    'w-full table-fixed border-collapse text-sm',
+    formUi.ui.value.arrayTable?.ui?.table
+  )
+"
+        :style="{ minWidth }"
+      >
+        <thead
+          :class="
+  mergeFormUiClass(
+    'bg-elevated/70 text-left text-muted',
+    formUi.ui.value.arrayTable?.ui?.head
+  )
+"
+        >
+          <tr :class="formUi.ui.value.arrayTable?.ui?.headerRow">
+            <th
+              v-for="column in columns"
+              :key="column.key"
+              scope="col"
+              :class="
+  mergeFormUiClass(
+    'border-b border-r border-default px-3 py-2.5 font-medium last:border-r-0',
+    formUi.ui.value.arrayTable?.ui?.headerCell
+  )
+"
+            >
+              {{ fieldLabel(column) }}
+            </th>
+            <th
+              v-if="showActionsColumn"
+              scope="col"
+              :class="
+  mergeFormUiClass(
+    'w-36 border-b border-default px-2 py-2',
+    formUi.ui.value.arrayTable?.ui?.actionsHeader
+  )
+"
+            />
+          </tr>
+        </thead>
+        <component
+          :is="isDraggable ? VueDraggable : 'tbody'"
+          v-model="dragItems"
+          :tag="isDraggable ? 'tbody' : void 0"
+          :class="formUi.ui.value.arrayTable?.ui?.body"
+          handle=".array-table-drag-handle"
+          :animation="150"
+        >
+          <tr
+            v-for="(item, index) in items"
+            :key="itemRenderKey(item, index)"
+            :class="
+  mergeFormUiClass(
+    'align-middle transition-colors hover:bg-elevated/35 [&>*]:border-b [&>*]:border-default [&:last-child>*]:border-b-0',
+    formUi.ui.value.arrayTable?.ui?.row
+  )
+"
+          >
+            <td
+              v-for="column in columns"
+              :key="column.key"
+              :class="
+  mergeFormUiClass(
+    'border-r border-default px-3 py-2 last:border-r-0',
+    formUi.ui.value.arrayTable?.ui?.cell
+  )
+"
+            >
+              <div
+                :class="
+  mergeFormUiClass(
+    'flex min-h-9 w-full items-center',
+    formUi.ui.value.arrayTable?.ui?.control
+  )
+"
+              >
+                <FormFieldRenderer :field="column" :parent-path="rowPath(index)" bare />
+              </div>
+            </td>
+            <td
+              v-if="showActionsColumn"
+              :class="
+  mergeFormUiClass(
+    'whitespace-nowrap px-2 py-2 text-right',
+    formUi.ui.value.arrayTable?.ui?.actionsCell
+  )
+"
+            >
+              <UButton
+                v-if="isDraggable"
+                icon="i-lucide-grip-vertical"
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                :class="
+  mergeFormUiClass(
+    'array-table-drag-handle cursor-grab active:cursor-grabbing',
+    formUi.ui.value.arrayTable?.ui?.action
+  )
+"
+                aria-label="Drag row"
+              />
+              <UButton
+                v-if="resolveAction(field.actions?.moveUp, index)"
+                icon="i-lucide-arrow-up"
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                :class="formUi.ui.value.arrayTable?.ui?.action"
+                :disabled="index === 0"
+                aria-label="Move row up"
+                @click="moveItem(index, -1)"
+              />
+              <UButton
+                v-if="resolveAction(field.actions?.moveDown, index)"
+                icon="i-lucide-arrow-down"
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                :class="formUi.ui.value.arrayTable?.ui?.action"
+                :disabled="index === items.length - 1"
+                aria-label="Move row down"
+                @click="moveItem(index, 1)"
+              />
+              <UButton
+                v-if="resolveAction(field.actions?.deleteItem, index)"
+                icon="i-lucide-trash-2"
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                :class="formUi.ui.value.arrayTable?.ui?.action"
+                aria-label="Remove row"
+                @click="removeItem(index)"
+              />
+              <UButton
+                v-for="(action, actionIndex) in field.actions?.custom ?? []"
+                v-show="customActionVisible(index, actionIndex)"
+                :key="actionIndex"
+                :icon="action.icon"
+                color="neutral"
+                variant="ghost"
+                size="xs"
+                :class="formUi.ui.value.arrayTable?.ui?.action"
+                @click="runCustomAction(index, actionIndex)"
+              >
+                {{ resolveFormText(action.label) }}
+              </UButton>
+            </td>
+          </tr>
+          <tr v-if="items.length === 0">
+            <td
+              :colspan="columns.length + (showActionsColumn ? 1 : 0)"
+              :class="
+  mergeFormUiClass(
+    'px-3 py-10 text-center text-muted',
+    formUi.ui.value.arrayTable?.ui?.empty
+  )
+"
+            >
+              {{ resolveFormText(field.emptyLabel) ?? "No items yet" }}
+            </td>
+          </tr>
+        </component>
+      </table>
+    </div>
+    <UButton
+      v-if="canAdd"
+      icon="i-lucide-plus"
+      variant="soft"
+      :size="formUi.controlSize.value"
+      :class="mergeFormUiClass('justify-self-start', formUi.ui.value.arrayTable?.ui?.add)"
+      @click="addItem"
+    >
+      {{ resolveFormText(field.addItemLabel) ?? "Add row" }}
+    </UButton>
+  </section>
+</template>

package/dist/runtime/form/fields/array-table/component.vue.d.ts

@@ -0,0 +1,8 @@
+import type { FormArrayTableField } from './types.js';
+type __VLS_Props = {
+    field: FormArrayTableField;
+    path: readonly string[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/form/fields/array-table/config.d.ts

@@ -0,0 +1,12 @@
+export declare const arrayTableFieldKind: {
+    readonly type: "array-table";
+    readonly state: "passthrough";
+    readonly ui: {
+        readonly label: true;
+        readonly description: true;
+    };
+    readonly layout: {
+        readonly item: true;
+        readonly container: true;
+    };
+};

package/dist/runtime/form/fields/array-table/config.js

@@ -0,0 +1,7 @@
+import { defineFormFieldKind } from "../../utils/field-kind.js";
+export const arrayTableFieldKind = defineFormFieldKind({
+  type: "array-table",
+  state: "passthrough",
+  ui: { label: true, description: true },
+  layout: { item: true, container: true }
+});

package/dist/runtime/form/fields/array-table/types.d.ts

@@ -0,0 +1,6 @@
+import type { FormArrayListField } from '../array-list/types.js';
+export interface FormArrayTableField<TContext = {}, TDeps = {}> extends Omit<FormArrayListField<TContext, TDeps>, 'type'> {
+    type: 'array-table';
+    minWidth?: number | string;
+}
+export type ArrayTableFieldOutput<TChildren> = readonly TChildren[];

package/dist/runtime/form/fields/array-tabs/config.d.ts

@@ -0,0 +1,12 @@
+export declare const arrayTabsFieldKind: {
+    readonly type: "array-tabs";
+    readonly state: "passthrough";
+    readonly ui: {
+        readonly label: true;
+        readonly description: true;
+    };
+    readonly layout: {
+        readonly item: true;
+        readonly container: true;
+    };
+};

package/dist/runtime/form/fields/array-tabs/config.js

@@ -0,0 +1,7 @@
+import { defineFormFieldKind } from "../../utils/field-kind.js";
+export const arrayTabsFieldKind = defineFormFieldKind({
+  type: "array-tabs",
+  state: "passthrough",
+  ui: { label: true, description: true },
+  layout: { item: true, container: true }
+});

package/dist/runtime/form/fields/array-tabs/index.d.ts

@@ -0,0 +1,2 @@
+export { arrayTabsFieldKind } from './config.js';
+export type * from './types';

package/dist/runtime/form/fields/array-tabs/index.js

@@ -0,0 +1 @@
+export { arrayTabsFieldKind } from "./config.js";

package/dist/runtime/form/fields/array-tabs/types.d.ts

@@ -0,0 +1,17 @@
+import type { FormContainerFieldBase } from '../../types/field-base.js';
+import type { FormText } from '../../types/utils.js';
+import type { FormObject } from '../../types/utils.js';
+import type { FormArrayFieldActions, FormArrayVirtualFields } from '../array-list/types.js';
+export interface FormArrayTabsField<TContext = {}, TDeps = {}> extends FormContainerFieldBase<'array-tabs', TContext, TDeps> {
+    addItemLabel?: FormText;
+    emptyLabel?: FormText;
+    itemLabel?: FormText;
+    compact?: boolean;
+    confirmDelete?: boolean | FormText;
+    headerTemplate?: (item: FormObject, index: number, deps: TDeps) => FormText;
+    transformOnCreate?: (item: FormObject, index: number, deps: TDeps) => FormObject;
+    virtualFields?: FormArrayVirtualFields;
+    extraProperties?: boolean;
+    actions?: FormArrayFieldActions<TContext, TDeps>;
+}
+export type ArrayTabsFieldOutput<TChildren> = readonly TChildren[];

package/dist/runtime/form/fields/array-variant/config.d.ts

@@ -0,0 +1,12 @@
+export declare const arrayVariantFieldKind: {
+    readonly type: "array-variant";
+    readonly state: "passthrough";
+    readonly ui: {
+        readonly label: true;
+        readonly description: true;
+    };
+    readonly layout: {
+        readonly item: true;
+        readonly container: true;
+    };
+};

package/dist/runtime/form/fields/array-variant/config.js

@@ -0,0 +1,7 @@
+import { defineFormFieldKind } from "../../utils/field-kind.js";
+export const arrayVariantFieldKind = defineFormFieldKind({
+  type: "array-variant",
+  state: "passthrough",
+  ui: { label: true, description: true },
+  layout: { item: true, container: true }
+});

package/dist/runtime/form/fields/array-variant/index.d.ts

@@ -0,0 +1,2 @@
+export { arrayVariantFieldKind } from './config.js';
+export type * from './types';

package/dist/runtime/form/fields/array-variant/index.js

@@ -0,0 +1 @@
+export { arrayVariantFieldKind } from "./config.js";

package/dist/runtime/form/fields/array-variant/types.d.ts

@@ -0,0 +1,38 @@
+import type { FormFieldCallback } from '../../types/callbacks.js';
+import type { FormField } from '../../types/field.js';
+import type { FormContainerLayout } from '../../types/layout.js';
+import type { FormDynamic, FormObject, FormText } from '../../types/utils.js';
+import type { FormArrayFieldActions, FormArrayVirtualFields } from '../array-list/types.js';
+export interface FormArrayVariant<TContext = {}, TDeps = {}> {
+    key: string | number;
+    label: FormText;
+    fields: readonly FormField<TContext, TDeps>[];
+    virtualFields?: FormArrayVirtualFields;
+}
+export interface FormArrayVariantField<TContext = {}, TDeps = {}> {
+    key: string;
+    type: 'array-variant';
+    label?: FormText;
+    description?: FormText;
+    layout?: FormContainerLayout;
+    condition?: FormFieldCallback<boolean, TContext, TDeps>;
+    ignore?: boolean;
+    props?: FormDynamic<FormObject, {
+        ctx: TContext;
+        deps: TDeps;
+    }>;
+    variantKey: string;
+    variants: readonly FormArrayVariant<TContext, TDeps>[];
+    displayMode?: 'list' | 'tabs';
+    addItemLabel?: FormText;
+    emptyLabel?: FormText;
+    itemLabel?: FormText;
+    compact?: boolean;
+    draggable?: boolean;
+    confirmDelete?: boolean | FormText;
+    headerTemplate?: (item: FormObject, index: number, deps: TDeps) => FormText;
+    transformOnCreate?: (item: FormObject, index: number, deps: TDeps) => FormObject;
+    extraProperties?: boolean;
+    actions?: FormArrayFieldActions<TContext, TDeps>;
+}
+export type ArrayVariantFieldOutput<TChildren> = readonly TChildren[];

package/dist/runtime/form/fields/auto-complete/component.d.vue.ts

@@ -0,0 +1,8 @@
+import type { FormAutoCompleteField } from '../../types/index.js';
+type __VLS_Props = {
+    field: FormAutoCompleteField;
+    path: readonly string[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/form/fields/auto-complete/component.vue

@@ -0,0 +1,110 @@
+<script setup>
+import UButton from "@nuxt/ui/components/Button.vue";
+import UInputMenu from "@nuxt/ui/components/InputMenu.vue";
+import { computed, ref } from "vue";
+import FormFieldShell from "../../components/renderer/FormFieldShell.vue";
+import { useFieldControl } from "../../composables/use-field-control";
+const props = defineProps({
+  field: { type: Object, required: true },
+  path: { type: Array, required: true }
+});
+const { form, controlProps, disabled, handleBlur, options, placeholder } = useFieldControl(
+  () => props.field,
+  () => props.path
+);
+const searchTerm = ref("");
+const model = computed({
+  get: () => {
+    const value = form.getValue(props.path);
+    if (Array.isArray(value)) return value.filter(isOptionValue);
+    if (isOptionValue(value)) return value;
+    return null;
+  },
+  set: (value) => form.setValue(props.path, value)
+});
+const items = computed(() => [...options.items.value]);
+const createItem = computed(
+  () => options.creatable.value ? props.field.createItem ?? { position: "bottom", when: "empty" } : false
+);
+const showFooterActions = computed(() => options.refreshable.value || options.creatable.value);
+const footerActionsClass = computed(
+  () => options.refreshable.value && options.creatable.value ? "sm:grid-cols-2" : "grid-cols-1"
+);
+const createActionLabel = computed(() => options.createLabel.value ?? "Create option");
+async function handleCreate(label) {
+  const option = await options.create(label);
+  if (!option || !options.selectCreatedOption.value) return;
+  if (props.field.multiple) {
+    const current = Array.isArray(model.value) ? model.value.filter(isOptionValue) : [];
+    model.value = [...current, option.value];
+    return;
+  }
+  model.value = option.value;
+}
+async function handleCreateAction() {
+  await handleCreate(searchTerm.value);
+}
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+</script>
+
+<template>
+  <FormFieldShell :field="field" :path="path">
+    <UInputMenu
+      v-model="model"
+      v-model:search-term="searchTerm"
+      v-bind="controlProps"
+      class="w-full"
+      value-key="value"
+      label-key="label"
+      :items="items"
+      :multiple="field.multiple"
+      :placeholder="placeholder"
+      :disabled="disabled"
+      :loading="options.loading.value || options.creating.value"
+      :clear="field.clearable === true"
+      :create-item="createItem"
+      @create="handleCreate"
+      @blur="handleBlur"
+    >
+      <template #create-item-label="{ item }">
+        {{ options.creating.value ? "Creating..." : `Create "${item}"` }}
+      </template>
+
+      <template #content-bottom>
+        <div
+          v-if="showFooterActions"
+          class="grid gap-1 border-t border-default p-1"
+          :class="footerActionsClass"
+        >
+          <UButton
+            v-if="options.refreshable.value"
+            block
+            size="xs"
+            variant="ghost"
+            color="neutral"
+            icon="i-lucide-refresh-cw"
+            :loading="options.pending.value || options.fetching.value"
+            @click.stop="options.refresh"
+          >
+            Refresh
+          </UButton>
+          <UButton
+            v-if="options.creatable.value"
+            block
+            size="xs"
+            variant="ghost"
+            color="primary"
+            icon="i-lucide-plus"
+            :loading="options.creating.value"
+            :disabled="disabled || options.creating.value"
+            @click.stop="handleCreateAction"
+          >
+            {{ createActionLabel }}
+          </UButton>
+        </div>
+      </template>
+    </UInputMenu>
+  </FormFieldShell>
+</template>

package/dist/runtime/form/fields/auto-complete/component.vue.d.ts

@@ -0,0 +1,8 @@
+import type { FormAutoCompleteField } from '../../types/index.js';
+type __VLS_Props = {
+    field: FormAutoCompleteField;
+    path: readonly string[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/form/fields/auto-complete/config.d.ts

@@ -0,0 +1,17 @@
+export declare const autoCompleteFieldKind: {
+    readonly type: "auto-complete";
+    readonly state: "stateful";
+    readonly ui: {
+        readonly label: true;
+        readonly description: true;
+        readonly hint: true;
+    };
+    readonly layout: {
+        readonly item: true;
+    };
+    readonly options: {
+        readonly enabled: true;
+    };
+    readonly validation: true;
+    readonly transform: true;
+};

package/dist/runtime/form/fields/auto-complete/config.js

@@ -0,0 +1,10 @@
+import { defineFormFieldKind } from "../../utils/field-kind.js";
+export const autoCompleteFieldKind = defineFormFieldKind({
+  type: "auto-complete",
+  state: "stateful",
+  ui: { label: true, description: true, hint: true },
+  layout: { item: true },
+  options: { enabled: true },
+  validation: true,
+  transform: true
+});

package/dist/runtime/form/fields/auto-complete/index.d.ts

@@ -0,0 +1,2 @@
+export { autoCompleteFieldKind } from './config.js';
+export type { AutoCompleteFieldOutput, FormAutoCompleteField } from './types.js';

package/dist/runtime/form/fields/auto-complete/index.js

@@ -0,0 +1 @@
+export { autoCompleteFieldKind } from "./config.js";