@knitify/vue 2.0.0 → 2.2.0

package/dist/types/index.d.ts

@@ -1,8 +1,17 @@
-import { App } from 'vue';
+import type { App, Component } from 'vue';
+import type { KDataTableColumnType } from './components/DataTable/types';
+export type KnitifyOptions = {
+    /**
+     * KDataTable column types to register, keyed by type name — the same as
+     * calling `registerColumnType` for each. Declare each name in
+     * `KDataTableColumnTypes` first.
+     */
+    columnTypes?: Partial<Record<KDataTableColumnType, Component>>;
+};
 export * from './types';
 export * from './components/types';
 export * from './components';
 declare const _default: {
-    install(app: App): void;
+    install(app: App, options?: KnitifyOptions): void;
 };
 export default _default;

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

@@ -0,0 +1,30 @@
+import type { ShallowRef } from 'vue';
+type Destroyable = {
+    destroy(): void;
+};
+type Options<Config, Controls> = {
+    root: Readonly<ShallowRef<HTMLElement | null>>;
+    /** Builds the core module on the root. */
+    create: (node: HTMLElement, config: Config) => Controls & Destroyable;
+    /** Read inside a watcher, so every prop it touches triggers a rebuild. */
+    config: () => Config;
+    /** Pushes the current model into a freshly built module. */
+    apply: (instance: Controls) => void;
+    listeners: Record<string, (event: CustomEvent) => void>;
+};
+/**
+ * The lifecycle the form-field wrappers share. Core reads its config once, in
+ * the constructor, so a config change means a rebuild rather than an update.
+ * Vue owns the root; core owns everything it renders inside.
+ */
+export declare function useCoreModule<Config, Controls>({ root, create, config, apply, listeners, }: Options<Config, Controls>): {
+    getInstance: () => Controls | undefined;
+};
+/**
+ * Core disables a field's × while it is empty, but only when it paints. One
+ * the template inserts later takes its state from the root's `is-empty`,
+ * which core keeps current, so it never sits enabled with nothing to clear.
+ * Bound as a function ref: Vue calls it each time the button renders.
+ */
+export declare function syncClearButtonFor(rootSelector: string): (element: unknown) => void;
+export {};

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

@@ -0,0 +1,25 @@
+type Attrs = Record<string, unknown>;
+export type UseFieldControlOptions = {
+    /** The control's own `disabled` prop. */
+    disabled: () => boolean;
+    /**
+     * The control is a button (KSelect's toggle). A button's name comes from its
+     * content, so it is labelled by the field label plus itself. It takes no
+     * `aria-required`, which ARIA does not allow on a button, so a required
+     * field's hidden "required" text joins its `aria-labelledby` instead.
+     */
+    button?: boolean;
+};
+/**
+ * Merges the enclosing KField's ids and state onto a control's native element.
+ * Outside a KField it hands `baseAttrs` back untouched. Inside a group field
+ * the ARIA lives on the fieldset, so only `disabled` is inherited.
+ *
+ * A non-group field wires exactly one control: two would share its id.
+ */
+export declare function useFieldControl(baseAttrs: () => Attrs, options: UseFieldControlOptions): {
+    controlAttrs: import("vue").ComputedRef<Attrs>;
+    isDisabled: import("vue").ComputedRef<boolean>;
+    field: import("..").FieldContext | undefined;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import { type ClassValue, type Ref } from 'vue';
+/**
+ * Applies `classes` to `element` with `classList`, for a root whose classes
+ * core also writes.
+ *
+ * Core adds and removes its state classes (`is-active`, `is-shown`, …) on the
+ * root itself. A `:class` binding cannot share the element with it: whenever
+ * the bound value changes, Vue assigns `className` outright, wiping every class
+ * core added — so changing a modifier while the component was open hid it.
+ * Adding and removing only the classes this owns leaves core's alone.
+ *
+ * The root keeps its base class as a static `class` in the template. Vue
+ * writes that once, when the element is created, and never patches it.
+ */
+export declare function useRootClasses(element: Readonly<Ref<HTMLElement | null>>, classes: () => ClassValue): void;

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

@@ -14,4 +14,6 @@ import { type Ref } from 'vue';
  * regardless of which opened last, since the latter is a persistent panel
  * rather than something Escape should dismiss.
  */
-export declare function useTopmost(name: string, active: Ref<boolean>, priority?: () => number): () => boolean;
+export declare function useTopmost(name: string, active: Ref<boolean>, priority?: () => number): (() => boolean) & {
+    depth: Readonly<Ref<number, number>>;
+};