lkt-vue-kernel 1.0.2 → 1.0.4

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+import { RouteLocationRaw } from 'vue-router';
+import { VueElement } from 'vue';
+
 interface LktObject {
-    [key: string]: any;
+    [key: string | number]: any;
 }
 
 declare enum FieldType {
@@ -37,28 +40,52 @@ interface OptionConfig {
 }
 
 declare class LktItem implements LktObject {
-    lktDateProps: string[];
-    lktStrictItem: boolean;
-    feed(data?: LktObject): void;
+    static lktAllowUndefinedProps: string[];
+    static lktExcludedProps: string[];
+    static lktDateProps: string[];
+    static lktStrictItem: boolean;
+    static lktDefaultValues: (keyof LktObject)[];
+    constructor(data?: LktObject);
+    feed(data?: LktObject, target?: this): void;
     assignProp(key: string, value: any): void;
 }
 
+type ValidModalName = string | Function | undefined;
+
 declare class Option extends LktItem implements OptionConfig {
     value: ValidOptionValue;
     label: string;
-    data?: LktObject;
-    disabled?: boolean;
-    group?: string;
-    icon?: string;
-    modal?: string | Function;
+    data: LktObject;
+    disabled: boolean;
+    group: string;
+    icon: string;
+    modal: ValidModalName;
+    constructor(data?: LktObject);
 }
 
 type ValidFieldValue = string | number | boolean | LktObject | Option[];
 
+declare enum MultipleOptionsDisplay {
+    List = "list",
+    Inline = "inline",
+    Count = "count"
+}
+
+type ValidTabIndex = string | number | undefined;
+
+declare enum FieldAutoValidationTrigger {
+    None = "",
+    Focus = "focus",
+    Blur = "blur",
+    Always = "always"
+}
+
+type ValidFieldMinMax = number | string | undefined;
+
 interface FieldConfig {
-    modelValue: ValidFieldValue;
+    modelValue?: ValidFieldValue;
     type?: FieldType;
-    valid?: boolean;
+    valid?: boolean | undefined;
     placeholder?: string;
     searchPlaceholder?: string;
     label?: string;
@@ -70,7 +97,7 @@ interface FieldConfig {
     readonly?: boolean;
     readMode?: boolean;
     allowReadModeSwitch?: boolean;
-    tabindex?: number;
+    tabindex?: ValidTabIndex;
     mandatory?: boolean;
     showPassword?: boolean;
     canClear?: boolean;
@@ -81,33 +108,33 @@ interface FieldConfig {
     mandatoryMessage?: string;
     infoMessage?: string;
     errorMessage?: string;
-    min?: number | string | undefined;
-    max?: number | string | undefined;
+    min?: ValidFieldMinMax;
+    max?: ValidFieldMinMax;
     step?: number | string;
     enableAutoNumberFix?: boolean;
     emptyValueSlot?: string;
-    optionSlot?: string;
-    valueSlot?: string;
-    editSlot?: string;
+    optionSlot?: string | undefined;
+    valueSlot?: string | undefined;
+    editSlot?: string | undefined;
     slotData?: LktObject;
     resource?: string;
     resourceData?: LktObject;
     validationResource?: string;
     validationResourceData?: LktObject;
     autoValidation?: boolean;
-    autoValidationType?: 'focus' | 'blur' | 'always';
+    autoValidationType?: FieldAutoValidationTrigger;
     validationStack?: string;
-    minNumbers?: number | string | undefined;
-    maxNumbers?: number | string | undefined;
-    minChars?: number | string | undefined;
-    maxChars?: number | string | undefined;
-    minUpperChars?: number | string | undefined;
-    maxUpperChars?: number | string | undefined;
-    minLowerChars?: number | string | undefined;
-    maxLowerChars?: number | string | undefined;
-    minSpecialChars?: number | string | undefined;
-    maxSpecialChars?: number | string | undefined;
-    checkEqualTo?: number | string | undefined;
+    minNumbers?: ValidFieldMinMax;
+    maxNumbers?: ValidFieldMinMax;
+    minChars?: ValidFieldMinMax;
+    maxChars?: ValidFieldMinMax;
+    minUpperChars?: ValidFieldMinMax;
+    maxUpperChars?: ValidFieldMinMax;
+    minLowerChars?: ValidFieldMinMax;
+    maxLowerChars?: ValidFieldMinMax;
+    minSpecialChars?: ValidFieldMinMax;
+    maxSpecialChars?: ValidFieldMinMax;
+    checkEqualTo?: ValidFieldMinMax;
     featuredButton?: string;
     infoButtonEllipsis?: boolean;
     fileName?: string;
@@ -115,15 +142,15 @@ interface FieldConfig {
     customButtonClass?: string;
     options?: string | Option[];
     multiple?: boolean;
-    multipleDisplay?: LktObject;
-    multipleDisplayEdition?: LktObject;
+    multipleDisplay?: MultipleOptionsDisplay;
+    multipleDisplayEdition?: MultipleOptionsDisplay;
     searchable?: boolean;
     autoloadOptionsResource?: boolean | 'feed';
     optionsDownload?: string | Function;
     optionsModal?: string | Function;
     optionsModalData?: LktObject | Function;
     optionsIcon?: string | Function;
-    optionsLabelFormatter?: Function;
+    optionsLabelFormatter?: Function | undefined;
     optionsResource?: string;
     optionsResourceData?: LktObject;
     icon?: string | Function;
@@ -138,24 +165,24 @@ interface FieldConfig {
 
 type EmptyModalKey = '_';
 
-type ValidModalKey = string | EmptyModalKey;
+type ValidModalKey = string | Function | EmptyModalKey;
 
-interface ModalConfig {
+interface ModalConfig extends LktObject {
     size?: string;
     preTitle?: string;
     preTitleIcon?: string;
     title?: string;
     closeIcon?: string;
-    closeConfirm?: string;
-    closeConfirmKey?: string;
+    closeConfirm?: ValidModalName;
+    closeConfirmKey?: ValidModalKey;
     showClose?: boolean;
     disabledClose?: boolean;
     disabledVeilClick?: boolean;
     hiddenFooter?: boolean;
-    modalName?: string;
+    modalName?: ValidModalName;
     modalKey?: ValidModalKey;
     zIndex?: number;
-    beforeClose?: Function;
+    beforeClose?: Function | undefined;
     item?: LktObject;
 }
 
@@ -190,22 +217,407 @@ interface TooltipConfig {
     referrerMargin?: number | string;
     windowMargin?: number | string;
     referrerWidth?: boolean;
-    referrer: HTMLElement;
+    referrer?: HTMLElement | undefined;
     locationY?: TooltipLocationY;
     locationX?: TooltipLocationX;
 }
 
+declare enum AnchorType {
+    Href = "href",// Vanilla JS+HTML anchor
+    RouterLink = "router-link",// For vue-router integration
+    RouterLinkBack = "router-link-back",// For vue-router back navigation
+    Mail = "mail",// Triggers OS mail integration
+    Tel = "tel",// Triggers OS phone integration
+    Tab = "tab",// New tab, similar to target="_blank"
+    Download = "download",// Download link
+    Action = "action",// Performs an action, without route changes
+    Legacy = ""
+}
+
+interface AnchorConfig {
+    type?: AnchorType;
+    to?: RouteLocationRaw | string;
+    class?: string;
+    isActive?: boolean;
+    downloadFileName?: string;
+    disabled?: boolean;
+    onClick?: Function | undefined;
+    confirmModal?: ValidModalName;
+    confirmModalKey?: ValidModalKey;
+    confirmData?: ModalConfig;
+    imposter?: boolean;
+}
+
+interface DragConfig {
+    isDraggable?: boolean | Function;
+    isValid?: Function;
+    canRender?: boolean | Function;
+    dragKey?: string;
+}
+
+declare const enum ButtonType {
+    Button = "button",// Default
+    Submit = "submit",// Form submit
+    Reset = "reset",
+    Anchor = "anchor",// Turns on anchor mode
+    Content = "content",// No click event
+    Switch = "switch",// Has a visible boolean state
+    HiddenSwitch = "hidden-switch",// Has a hidden boolean state
+    Split = "split",// Split button, content always generated
+    SplitLazy = "split-lazy",// Split button, contents generated after first open
+    SplitEver = "split-ever",// Split button, contents generated each time it's clicked
+    Tooltip = "tooltip",// Tooltip button, content always generated
+    TooltipLazy = "tooltip-lazy",// Tooltip button, contents generated after first open
+    TooltipEver = "tooltip-ever"
+}
+
+declare enum ToggleMode {
+    Lazy = "lazy",
+    Ever = "ever"
+}
+
+declare class Anchor extends LktItem implements AnchorConfig {
+    static lktAllowUndefinedProps: string[];
+    static lktDefaultValues: (keyof AnchorConfig)[];
+    type: AnchorType;
+    to?: RouteLocationRaw | string;
+    class: string;
+    isActive: boolean;
+    downloadFileName: string;
+    disabled: boolean;
+    onClick: Function | undefined;
+    confirmModal: ValidModalName;
+    confirmModalKey: ValidModalKey;
+    confirmData: LktObject;
+    imposter: boolean;
+    constructor(data?: Partial<AnchorConfig>);
+    getHref(): string;
+}
+
+interface ButtonConfig {
+    type?: ButtonType;
+    checked?: boolean;
+    openTooltip?: boolean;
+    name?: string;
+    text?: string | number;
+    icon?: string;
+    class?: string;
+    containerClass?: string;
+    palette?: string;
+    value?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    wrapContent?: boolean;
+    anchor?: AnchorConfig | Anchor;
+    resource?: string;
+    resourceData?: LktObject;
+    modal?: ValidModalName;
+    modalKey?: ValidModalKey;
+    modalData?: ModalConfig;
+    confirmModal?: ValidModalName;
+    confirmModalKey?: ValidModalKey;
+    confirmData?: ModalConfig;
+    iconDot?: boolean | string | number;
+    iconEnd?: string;
+    img?: string;
+    split?: boolean | ToggleMode;
+    splitIcon?: string;
+    tooltip?: boolean | ToggleMode;
+    tooltipEngine?: TooltipPositionEngine;
+    showTooltipOnHover?: boolean;
+    showTooltipOnHoverDelay?: number;
+    hideTooltipOnLeave?: boolean;
+    tooltipWindowMargin?: number;
+    tooltipReferrerMargin?: number;
+    tooltipClass?: string;
+    tooltipLocationY?: string;
+    tooltipLocationX?: string;
+    splitClass?: string;
+    clickRef?: Element | VueElement;
+    tabindex?: ValidTabIndex;
+    isAnchor?: boolean;
+    onClickTo?: string;
+    onClickToExternal?: boolean;
+    download?: boolean;
+    downloadFileName?: string;
+    newTab?: boolean;
+    showSwitch?: boolean;
+    hiddenSwitch?: boolean;
+}
+
 declare class LktStrictItem extends LktItem {
     lktStrictItem: boolean;
 }
 
-declare const enum ButtonType {
+declare class Field extends LktItem implements FieldConfig {
+    modelValue: ValidFieldValue;
+    type: FieldType;
+    valid: boolean | undefined;
+    placeholder: string;
+    searchPlaceholder: string;
+    label: string;
+    labelIcon: string;
+    labelIconAtEnd: boolean;
+    name: string;
+    autocomplete: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    readMode: boolean;
+    allowReadModeSwitch: boolean;
+    tabindex: ValidTabIndex;
+    mandatory: boolean;
+    showPassword: boolean;
+    canClear: boolean;
+    canUndo: boolean;
+    canI18n: boolean;
+    canStep: boolean;
+    mandatoryMessage: string;
+    infoMessage: string;
+    errorMessage: string;
+    min: ValidFieldMinMax;
+    max: ValidFieldMinMax;
+    step: number | string;
+    enableAutoNumberFix: boolean;
+    emptyValueSlot: string;
+    optionSlot: undefined;
+    valueSlot: undefined;
+    editSlot: undefined;
+    slotData: LktObject;
+    resource: string;
+    resourceData: LktObject;
+    validationResource: string;
+    validationResourceData: LktObject;
+    autoValidation: boolean;
+    autoValidationType: FieldAutoValidationTrigger;
+    validationStack: string;
+    minNumbers: ValidFieldMinMax;
+    maxNumbers: ValidFieldMinMax;
+    minChars: ValidFieldMinMax;
+    maxChars: ValidFieldMinMax;
+    minUpperChars: ValidFieldMinMax;
+    maxUpperChars: ValidFieldMinMax;
+    minLowerChars: ValidFieldMinMax;
+    maxLowerChars: ValidFieldMinMax;
+    minSpecialChars: ValidFieldMinMax;
+    maxSpecialChars: ValidFieldMinMax;
+    checkEqualTo: ValidFieldMinMax;
+    featuredButton: string;
+    infoButtonEllipsis: boolean;
+    fileName: string;
+    customButtonText: string;
+    customButtonClass: string;
+    options: string | Option[];
+    multiple: boolean;
+    multipleDisplay: MultipleOptionsDisplay;
+    multipleDisplayEdition: MultipleOptionsDisplay;
+    searchable: boolean;
+    autoloadOptionsResource: boolean | 'feed';
+    optionsDownload: string | Function;
+    optionsModal: string | Function;
+    optionsModalData: LktObject | Function;
+    optionsIcon: string | Function;
+    optionsLabelFormatter: undefined;
+    optionsResource: string;
+    optionsResourceData: LktObject;
+    icon: string | Function;
+    download: string | Function;
+    modal: string | Function;
+    modalKey: string | number | Function;
+    modalData: LktObject;
+    data: LktObject;
+    constructor(data?: FieldConfig);
+}
+
+declare enum ColumnType {
+    None = "",
+    Field = "field",
     Button = "button",
-    Submit = "submit",
-    Reset = "reset",
-    Content = "content",
+    Anchor = "anchor",
+    Text = "text",
+    Number = "number",
+    Check = "check",
     Switch = "switch",
-    HiddenSwitch = "hidden-switch"
+    Select = "select",
+    Email = "email",
+    Tel = "tel",
+    File = "file",
+    Link = "link",
+    Action = "action",
+    Integer = "int",
+    Float = "float"
+}
+
+type ValidSafeStringValue = string | ((...args: any[]) => string) | undefined | SafeString;
+
+declare class SafeString {
+    private readonly value;
+    constructor(input: ValidSafeStringValue);
+    getValue(...args: any[]): string;
+}
+
+type ValidColSpan = Function | boolean | number | undefined;
+
+declare class Button extends LktItem implements ButtonConfig {
+    lktAllowUndefinedProps: string[];
+    type: ButtonType;
+    name: string;
+    palette: string;
+    onClickTo: string;
+    onClickToExternal: boolean;
+    class: string;
+    containerClass: string;
+    value: string;
+    disabled: boolean;
+    loading: boolean;
+    wrapContent: boolean;
+    split: boolean;
+    splitIcon: string;
+    isAnchor: boolean;
+    resource: string;
+    resourceData: LktObject;
+    modal: ValidModalName;
+    modalKey: ValidModalKey;
+    modalData: ModalConfig;
+    confirmModal: ValidModalName;
+    confirmModalKey: ValidModalKey;
+    confirmData: ModalConfig;
+    text: string;
+    icon: string;
+    iconDot: boolean;
+    iconEnd: string;
+    img: string;
+    newTab: boolean;
+    download: boolean;
+    downloadFileName: string;
+    tooltip: boolean;
+    showTooltipOnHoverDelay: number;
+    tooltipWindowMargin: number;
+    tooltipReferrerMargin: number;
+    tooltipLocationY: string;
+    tooltipLocationX: string;
+    checked: boolean;
+    clickRef?: Element | VueElement;
+    openTooltip: boolean;
+    tabindex: ValidTabIndex;
+    anchor?: AnchorConfig | Anchor;
+    tooltipEngine?: TooltipPositionEngine;
+    showTooltipOnHover?: boolean;
+    hideTooltipOnLeave?: boolean;
+    tooltipClass?: string;
+    splitClass?: string;
+    constructor(data?: ButtonConfig);
 }
 
-export { ButtonType, type EmptyModalKey, type FieldConfig, FieldType, LktItem, type LktObject, LktStrictItem, type ModalConfig, Option, type OptionConfig, type TooltipConfig, TooltipLocationX, TooltipLocationY, TooltipPositionEngine, type ValidFieldValue, type ValidModalKey, type ValidOptionValue };
+interface ColumnConfig {
+    type: ColumnType;
+    key: string;
+    label: string;
+    sortable: boolean;
+    hidden: boolean;
+    editable: boolean;
+    formatter?: Function | undefined;
+    checkEmpty?: Function | undefined;
+    colspan?: ValidColSpan;
+    preferSlot?: Function | boolean;
+    isForRowKey?: boolean;
+    extractTitleFromColumn?: string;
+    slotData?: LktObject;
+    field?: Field | FieldConfig | undefined;
+    anchor?: Anchor | AnchorConfig | undefined;
+    button?: Button | ButtonConfig | undefined;
+    link?: ValidSafeStringValue | SafeString;
+    action?: Function;
+}
+
+declare class Column extends LktItem implements ColumnConfig {
+    lktExcludedProps: string[];
+    lktAllowUndefinedProps: string[];
+    type: ColumnType;
+    key: string;
+    label: string;
+    sortable: boolean;
+    hidden: boolean;
+    editable: boolean;
+    formatter: Function | undefined;
+    checkEmpty: Function | undefined;
+    colspan: ValidColSpan;
+    preferSlot: Function | boolean;
+    isForRowKey: boolean;
+    extractTitleFromColumn: string;
+    slotData: LktObject;
+    field: Field | FieldConfig | undefined;
+    anchor: Anchor | AnchorConfig | undefined;
+    button: Button | ButtonConfig | undefined;
+    link: ValidSafeStringValue | SafeString | undefined;
+    action?: Function;
+    constructor(data: ColumnConfig);
+    getHref(item: LktObject): string;
+    doAction(item: LktObject): any;
+}
+
+declare class Tooltip extends LktItem implements TooltipConfig {
+    static lktDefaultValues: (keyof TooltipConfig)[];
+    modelValue: boolean;
+    alwaysOpen: boolean;
+    class: string;
+    text: string;
+    icon: string;
+    iconAtEnd: boolean;
+    engine: TooltipPositionEngine;
+    referrerWidth: boolean;
+    referrerMargin: number | string;
+    windowMargin: number | string;
+    referrer: HTMLElement | undefined;
+    locationY: TooltipLocationY;
+    locationX: TooltipLocationX;
+    constructor(data?: FieldConfig);
+}
+
+declare class Modal extends LktItem implements ModalConfig {
+    static lktDefaultValues: (keyof ModalConfig)[];
+    size: string;
+    preTitle: string;
+    preTitleIcon: string;
+    title: string;
+    closeIcon: string;
+    closeConfirm: ValidModalName;
+    closeConfirmKey: ValidModalKey;
+    showClose: boolean;
+    disabledClose: boolean;
+    disabledVeilClick: boolean;
+    hiddenFooter: boolean;
+    modalName: ValidModalName;
+    modalKey: ValidModalKey;
+    zIndex: number;
+    beforeClose: Function | undefined;
+    item: LktObject;
+    constructor(data?: FieldConfig);
+}
+
+declare enum ModalType {
+    Modal = "modal",
+    Confirm = "confirm"
+}
+
+declare enum SortDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
+
+declare enum TableType {
+    Table = "table",
+    Item = "item",
+    Ul = "ul",
+    Ol = "ol"
+}
+
+/**
+ * Export common interfaces
+ */
+
+declare function getDefaultValues<T>(cls: {
+    new (): T;
+    lktDefaultValues: (keyof T)[];
+}): Partial<T>;
+
+export { Anchor, type AnchorConfig, AnchorType, Button, type ButtonConfig, ButtonType, Column, ColumnType, type DragConfig, type EmptyModalKey, Field, FieldAutoValidationTrigger, type FieldConfig, FieldType, LktItem, type LktObject, LktStrictItem, Modal, type ModalConfig, ModalType, MultipleOptionsDisplay, Option, type OptionConfig, SafeString, SortDirection, TableType, ToggleMode, Tooltip, type TooltipConfig, TooltipLocationX, TooltipLocationY, TooltipPositionEngine, type ValidColSpan, type ValidFieldMinMax, type ValidFieldValue, type ValidModalKey, type ValidModalName, type ValidOptionValue, type ValidSafeStringValue, type ValidTabIndex, getDefaultValues };

package/dist/index.js

@@ -1,18 +1,25 @@
 // src/instances/LktItem.ts
 var skipDataProps = [
   "lktDateProps",
-  "lktStrictItem"
+  "lktStrictItem",
+  "lktExcludedProps"
 ];
-var LktItem = class {
-  lktDateProps = [];
-  lktStrictItem = false;
-  feed(data = {}) {
-    for (const [key, value] of Object.entries(data)) this.assignProp(key, value);
+var LktItem = class _LktItem {
+  static lktAllowUndefinedProps = [];
+  static lktExcludedProps = [];
+  static lktDateProps = [];
+  static lktStrictItem = false;
+  static lktDefaultValues = [];
+  constructor(data) {
+  }
+  feed(data = {}, target = this) {
+    if (typeof data !== "object") return;
+    for (const [key, value] of Object.entries(data)) target.assignProp(key, value);
   }
   assignProp(key, value) {
-    if (skipDataProps.includes(key)) return;
-    if (this.lktStrictItem && !this.hasOwnProperty(key)) return;
-    if (this.lktDateProps.includes(key)) {
+    if (skipDataProps.includes(key) || _LktItem.lktExcludedProps.includes(key)) return;
+    if (_LktItem.lktStrictItem && !this.hasOwnProperty(key)) return;
+    if (_LktItem.lktDateProps.includes(key)) {
       this[key] = new Date(value);
       return;
     }
@@ -34,19 +41,12 @@ var Option = class extends LktItem {
   group = "";
   icon = "";
   modal = "";
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+  }
 };
 
-// src/enums/ButtonType.ts
-var ButtonType = /* @__PURE__ */ ((ButtonType2) => {
-  ButtonType2["Button"] = "button";
-  ButtonType2["Submit"] = "submit";
-  ButtonType2["Reset"] = "reset";
-  ButtonType2["Content"] = "content";
-  ButtonType2["Switch"] = "switch";
-  ButtonType2["HiddenSwitch"] = "hidden-switch";
-  return ButtonType2;
-})(ButtonType || {});
-
 // src/enums/FieldType.ts
 var FieldType = /* @__PURE__ */ ((FieldType2) => {
   FieldType2["Text"] = "text";
@@ -71,6 +71,363 @@ var FieldType = /* @__PURE__ */ ((FieldType2) => {
   return FieldType2;
 })(FieldType || {});
 
+// src/instances/Field.ts
+import { generateRandomString } from "lkt-string-tools";
+
+// src/enums/MultipleOptionsDisplay.ts
+var MultipleOptionsDisplay = /* @__PURE__ */ ((MultipleOptionsDisplay2) => {
+  MultipleOptionsDisplay2["List"] = "list";
+  MultipleOptionsDisplay2["Inline"] = "inline";
+  MultipleOptionsDisplay2["Count"] = "count";
+  return MultipleOptionsDisplay2;
+})(MultipleOptionsDisplay || {});
+
+// src/enums/FieldAutoValidationTrigger.ts
+var FieldAutoValidationTrigger = /* @__PURE__ */ ((FieldAutoValidationTrigger2) => {
+  FieldAutoValidationTrigger2["None"] = "";
+  FieldAutoValidationTrigger2["Focus"] = "focus";
+  FieldAutoValidationTrigger2["Blur"] = "blur";
+  FieldAutoValidationTrigger2["Always"] = "always";
+  return FieldAutoValidationTrigger2;
+})(FieldAutoValidationTrigger || {});
+
+// src/instances/Field.ts
+var Field = class extends LktItem {
+  modelValue = "";
+  type = "text" /* Text */;
+  valid = void 0;
+  placeholder = "";
+  searchPlaceholder = "";
+  label = "";
+  labelIcon = "";
+  labelIconAtEnd = false;
+  name = generateRandomString(16);
+  autocomplete = false;
+  disabled = false;
+  readonly = false;
+  readMode = false;
+  allowReadModeSwitch = false;
+  tabindex = void 0;
+  mandatory = false;
+  showPassword = false;
+  canClear = false;
+  canUndo = false;
+  canI18n = false;
+  canStep = true;
+  mandatoryMessage = "";
+  infoMessage = "";
+  errorMessage = "";
+  min = void 0;
+  max = void 0;
+  step = 1;
+  enableAutoNumberFix = true;
+  emptyValueSlot = "";
+  optionSlot = void 0;
+  valueSlot = void 0;
+  editSlot = void 0;
+  slotData = {};
+  resource = "";
+  resourceData = {};
+  validationResource = "";
+  validationResourceData = {};
+  autoValidation = false;
+  autoValidationType = "blur" /* Blur */;
+  validationStack = "default";
+  minNumbers = void 0;
+  maxNumbers = void 0;
+  minChars = void 0;
+  maxChars = void 0;
+  minUpperChars = void 0;
+  maxUpperChars = void 0;
+  minLowerChars = void 0;
+  maxLowerChars = void 0;
+  minSpecialChars = void 0;
+  maxSpecialChars = void 0;
+  checkEqualTo = void 0;
+  featuredButton = "";
+  infoButtonEllipsis = false;
+  fileName = "";
+  customButtonText = "";
+  customButtonClass = "";
+  options = [];
+  multiple = false;
+  multipleDisplay = "list" /* List */;
+  multipleDisplayEdition = "inline" /* Inline */;
+  searchable = false;
+  autoloadOptionsResource = false;
+  optionsDownload = "";
+  optionsModal = "";
+  optionsModalData = {};
+  optionsIcon = "";
+  optionsLabelFormatter = void 0;
+  optionsResource = "";
+  optionsResourceData = {};
+  icon = "";
+  download = "";
+  modal = "";
+  modalKey = "";
+  modalData = {};
+  data = {};
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+  }
+};
+
+// src/enums/ColumnType.ts
+var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
+  ColumnType2["None"] = "";
+  ColumnType2["Field"] = "field";
+  ColumnType2["Button"] = "button";
+  ColumnType2["Anchor"] = "anchor";
+  ColumnType2["Text"] = "text";
+  ColumnType2["Number"] = "number";
+  ColumnType2["Check"] = "check";
+  ColumnType2["Switch"] = "switch";
+  ColumnType2["Select"] = "select";
+  ColumnType2["Email"] = "email";
+  ColumnType2["Tel"] = "tel";
+  ColumnType2["File"] = "file";
+  ColumnType2["Link"] = "link";
+  ColumnType2["Action"] = "action";
+  ColumnType2["Integer"] = "int";
+  ColumnType2["Float"] = "float";
+  return ColumnType2;
+})(ColumnType || {});
+
+// src/value-objects/SafeString.ts
+var SafeString = class _SafeString {
+  value;
+  constructor(input) {
+    this.value = input;
+  }
+  getValue(...args) {
+    if (typeof this.value === "function") {
+      return this.value(...args);
+    } else if (typeof this.value === "object" && typeof this.value === typeof _SafeString) {
+      return this.value.getValue(...args);
+    } else if (typeof this.value === "string") {
+      return this.value;
+    }
+    return "";
+  }
+};
+
+// src/enums/AnchorType.ts
+var AnchorType = /* @__PURE__ */ ((AnchorType2) => {
+  AnchorType2["Href"] = "href";
+  AnchorType2["RouterLink"] = "router-link";
+  AnchorType2["RouterLinkBack"] = "router-link-back";
+  AnchorType2["Mail"] = "mail";
+  AnchorType2["Tel"] = "tel";
+  AnchorType2["Tab"] = "tab";
+  AnchorType2["Download"] = "download";
+  AnchorType2["Action"] = "action";
+  AnchorType2["Legacy"] = "";
+  return AnchorType2;
+})(AnchorType || {});
+
+// src/instances/Anchor.ts
+var Anchor = class extends LktItem {
+  static lktAllowUndefinedProps = [
+    "onClick"
+  ];
+  static lktDefaultValues = [
+    "type",
+    "to",
+    "class",
+    "isActive",
+    "downloadFileName",
+    "disabled",
+    "onClick",
+    "confirmModal",
+    "confirmModalKey",
+    "confirmData",
+    "imposter"
+  ];
+  type = "router-link" /* RouterLink */;
+  to = "";
+  class = "";
+  isActive = false;
+  downloadFileName = "";
+  disabled = false;
+  onClick = void 0;
+  confirmModal = "";
+  confirmModalKey = "_";
+  confirmData = {};
+  imposter = false;
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+  }
+  getHref() {
+    let href = "";
+    if (typeof this.to === "string") href = this.to;
+    if ("mail" /* Mail */ === this.type) return `mailto:${href}`;
+    if ("tel" /* Tel */ === this.type) return `tel:${href}`;
+    if ([
+      "href" /* Href */,
+      "mail" /* Mail */,
+      "tel" /* Tel */,
+      "tab" /* Tab */,
+      "download" /* Download */
+    ].includes(this.type)) {
+      return href;
+    }
+    if (typeof this.to === "string" && this.to !== "") return this.to;
+    return "";
+  }
+};
+
+// src/enums/ButtonType.ts
+var ButtonType = /* @__PURE__ */ ((ButtonType2) => {
+  ButtonType2["Button"] = "button";
+  ButtonType2["Submit"] = "submit";
+  ButtonType2["Reset"] = "reset";
+  ButtonType2["Anchor"] = "anchor";
+  ButtonType2["Content"] = "content";
+  ButtonType2["Switch"] = "switch";
+  ButtonType2["HiddenSwitch"] = "hidden-switch";
+  ButtonType2["Split"] = "split";
+  ButtonType2["SplitLazy"] = "split-lazy";
+  ButtonType2["SplitEver"] = "split-ever";
+  ButtonType2["Tooltip"] = "tooltip";
+  ButtonType2["TooltipLazy"] = "tooltip-lazy";
+  ButtonType2["TooltipEver"] = "tooltip-ever";
+  return ButtonType2;
+})(ButtonType || {});
+
+// src/instances/Button.ts
+import { generateRandomString as generateRandomString2 } from "lkt-string-tools";
+
+// src/enums/TooltipPositionEngine.ts
+var TooltipPositionEngine = /* @__PURE__ */ ((TooltipPositionEngine2) => {
+  TooltipPositionEngine2["Fixed"] = "fixed";
+  TooltipPositionEngine2["Absolute"] = "absolute";
+  return TooltipPositionEngine2;
+})(TooltipPositionEngine || {});
+
+// src/instances/Button.ts
+var Button = class extends LktItem {
+  lktAllowUndefinedProps = [
+    "clickRef",
+    "tabindex",
+    "anchor",
+    "showTooltipOnHover",
+    "hideTooltipOnLeave"
+  ];
+  type = "button" /* Button */;
+  name = generateRandomString2(10);
+  palette = "";
+  onClickTo = "";
+  onClickToExternal = false;
+  class = "";
+  containerClass = "";
+  value = "";
+  disabled = false;
+  loading = false;
+  wrapContent = false;
+  split = false;
+  splitIcon = "";
+  isAnchor = false;
+  resource = "";
+  resourceData = () => ({});
+  modal = "";
+  modalKey = "_";
+  modalData = () => ({});
+  confirmModal = "";
+  confirmModalKey = "_";
+  confirmData = () => ({});
+  text = "";
+  icon = "";
+  iconDot = false;
+  iconEnd = "";
+  img = "";
+  newTab = false;
+  download = false;
+  downloadFileName = "";
+  tooltip = false;
+  showTooltipOnHoverDelay = 0;
+  tooltipWindowMargin = 0;
+  tooltipReferrerMargin = 0;
+  tooltipLocationY = "bottom";
+  tooltipLocationX = "left-corner";
+  checked = false;
+  clickRef = void 0;
+  openTooltip = false;
+  tabindex = void 0;
+  anchor = void 0;
+  tooltipEngine = "fixed" /* Fixed */;
+  showTooltipOnHover = void 0;
+  hideTooltipOnLeave = void 0;
+  tooltipClass = "";
+  splitClass = "";
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+    this.anchor = new Anchor(data.anchor);
+  }
+};
+
+// src/instances/Column.ts
+var Column = class extends LktItem {
+  lktExcludedProps = ["link", "field", "anchor", "button"];
+  lktAllowUndefinedProps = [
+    "formatter",
+    "checkEmpty",
+    "colspan",
+    "field",
+    "anchor",
+    "button",
+    "link",
+    "action"
+  ];
+  type = "" /* None */;
+  key = "";
+  label = "";
+  sortable = true;
+  hidden = false;
+  editable = false;
+  formatter = void 0;
+  checkEmpty = void 0;
+  colspan = void 0;
+  preferSlot = true;
+  isForRowKey = false;
+  extractTitleFromColumn = "";
+  slotData = {};
+  field = void 0;
+  anchor = void 0;
+  button = void 0;
+  link = void 0;
+  action = void 0;
+  constructor(data) {
+    super();
+    this.feed(data);
+    switch (this.type) {
+      case "field" /* Field */:
+        this.field = new Field(data.field);
+        break;
+      case "anchor" /* Anchor */:
+        this.anchor = new Anchor(data.anchor);
+        break;
+      case "button" /* Button */:
+        this.button = new Button(data.button);
+        break;
+    }
+    this.link = new SafeString(data.link);
+  }
+  getHref(item) {
+    if (typeof this.link !== "object") return "";
+    return this.link.getValue(item);
+  }
+  doAction(item) {
+    if (typeof this.action === "function") {
+      return this.action(item);
+    }
+    console.warn("No action defined");
+  }
+};
+
 // src/enums/TooltipLocationY.ts
 var TooltipLocationY = /* @__PURE__ */ ((TooltipLocationY2) => {
   TooltipLocationY2["Top"] = "top";
@@ -90,19 +447,151 @@ var TooltipLocationX = /* @__PURE__ */ ((TooltipLocationX2) => {
   return TooltipLocationX2;
 })(TooltipLocationX || {});
 
-// src/enums/TooltipPositionEngine.ts
-var TooltipPositionEngine = /* @__PURE__ */ ((TooltipPositionEngine2) => {
-  TooltipPositionEngine2["Fixed"] = "fixed";
-  TooltipPositionEngine2["Absolute"] = "absolute";
-  return TooltipPositionEngine2;
-})(TooltipPositionEngine || {});
+// src/instances/Tooltip.ts
+var Tooltip = class extends LktItem {
+  static lktDefaultValues = [
+    "modelValue",
+    "alwaysOpen",
+    "class",
+    "text",
+    "icon",
+    "iconAtEnd",
+    "engine",
+    "referrerWidth",
+    "referrerMargin",
+    "windowMargin",
+    "referrer",
+    "locationY",
+    "locationX"
+  ];
+  modelValue = false;
+  alwaysOpen = false;
+  class = "";
+  text = "";
+  icon = "";
+  iconAtEnd = false;
+  engine = "fixed" /* Fixed */;
+  referrerWidth = false;
+  referrerMargin = 0;
+  windowMargin = 0;
+  referrer = void 0;
+  locationY = "bottom" /* Bottom */;
+  locationX = "left-corner" /* LeftCorner */;
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+  }
+};
+
+// src/instances/Modal.ts
+var Modal = class extends LktItem {
+  static lktDefaultValues = [
+    "size",
+    "preTitle",
+    "preTitleIcon",
+    "title",
+    "closeIcon",
+    "closeConfirm",
+    "closeConfirmKey",
+    "showClose",
+    "disabledClose",
+    "disabledVeilClick",
+    "hiddenFooter",
+    "modalName",
+    "modalKey",
+    "zIndex",
+    "beforeClose",
+    "item"
+  ];
+  size = "";
+  preTitle = "";
+  preTitleIcon = "";
+  title = "";
+  closeIcon = "";
+  closeConfirm = "";
+  closeConfirmKey = "_";
+  showClose = true;
+  disabledClose = false;
+  disabledVeilClick = false;
+  hiddenFooter = false;
+  modalName = "";
+  modalKey = "_";
+  zIndex = 500;
+  beforeClose = void 0;
+  item = {};
+  constructor(data = {}) {
+    super();
+    this.feed(data);
+  }
+};
+
+// src/enums/ModalType.ts
+var ModalType = /* @__PURE__ */ ((ModalType2) => {
+  ModalType2["Modal"] = "modal";
+  ModalType2["Confirm"] = "confirm";
+  return ModalType2;
+})(ModalType || {});
+
+// src/enums/SortDirection.ts
+var SortDirection = /* @__PURE__ */ ((SortDirection2) => {
+  SortDirection2["Asc"] = "asc";
+  SortDirection2["Desc"] = "desc";
+  return SortDirection2;
+})(SortDirection || {});
+
+// src/enums/TableType.ts
+var TableType = /* @__PURE__ */ ((TableType2) => {
+  TableType2["Table"] = "table";
+  TableType2["Item"] = "item";
+  TableType2["Ul"] = "ul";
+  TableType2["Ol"] = "ol";
+  return TableType2;
+})(TableType || {});
+
+// src/enums/ToggleMode.ts
+var ToggleMode = /* @__PURE__ */ ((ToggleMode2) => {
+  ToggleMode2["Lazy"] = "lazy";
+  ToggleMode2["Ever"] = "ever";
+  return ToggleMode2;
+})(ToggleMode || {});
+
+// src/index.ts
+function getDefaultValues(cls) {
+  const instance = new cls();
+  const result = {};
+  if (!Array.isArray(cls.lktDefaultValues)) {
+    throw new Error("lktDefaultValues must be a keys array.");
+  }
+  for (const key of cls.lktDefaultValues) {
+    if (key in instance) {
+      result[key] = instance[key];
+    }
+  }
+  return result;
+}
 export {
+  Anchor,
+  AnchorType,
+  Button,
   ButtonType,
+  Column,
+  ColumnType,
+  Field,
+  FieldAutoValidationTrigger,
   FieldType,
   LktItem,
   LktStrictItem,
+  Modal,
+  ModalType,
+  MultipleOptionsDisplay,
   Option,
+  SafeString,
+  SortDirection,
+  TableType,
+  ToggleMode,
+  Tooltip,
   TooltipLocationX,
   TooltipLocationY,
-  TooltipPositionEngine
+  TooltipPositionEngine,
+  getDefaultValues
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lkt-vue-kernel",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "LKT Vue Kernel",
   "keywords": [
     "lkt",
@@ -13,7 +13,9 @@
   "type": "module",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js"
@@ -31,5 +33,10 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "lkt-string-tools": "^1.0.8",
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.0"
   }
 }