@tekkare/auriga 0.1.0 → 0.1.3

package/dist/runtime/components/argTable.vue.d.ts

@@ -1,4 +1,338 @@
-declare const _default: {
-    name: string;
-};
+declare const _default: import("vue").DefineComponent<{
+    heads: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    contents: {
+        type: {
+            (arrayLength: number): Object[];
+            (...items: Object[]): Object[];
+            new (arrayLength: number): Object[];
+            new (...items: Object[]): Object[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+        default: () => {
+            values: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+                from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+                from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+                of<T_4>(...items: T_4[]): T_4[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+        }[];
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    sort: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    search: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchColumns: {
+        type: {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+    columnType: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    columnStyle: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    tooltipHeader: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    searchFullWord: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    toggleDisplay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagesPosition: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataValues: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    loadingData: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loaderType: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    sortCol: import("vue").Ref<any>;
+    sortDir: import("vue").Ref<any>;
+    currentPage: import("vue").Ref<any>;
+    sortIndex: import("vue").Ref<any>;
+    searchIndex: import("vue").Ref<any>;
+    searchKey: import("vue").Ref<any>;
+    showSearch: import("vue").Ref<boolean>;
+    saveTable: import("vue").Ref<never[]>;
+    columnTypeNonProps: import("vue").Ref<any>;
+    searchSubmit: import("vue").Ref<boolean>;
+    showFull: import("vue").Ref<boolean>;
+    savePageSize: import("vue").Ref<number>;
+    showToggle: import("vue").Ref<boolean>;
+    showLine: import("vue").Ref<any>;
+    openLine: (index: number) => void;
+    getTooltipDir: (index: number) => "left" | "bottom";
+    getColumnTypes: () => void;
+    isNA: (val: string) => boolean;
+    sortDatas: (index: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPage: (pageNumber: number) => void;
+    showPage: (pageNumber: number) => boolean;
+    limitA: (pageNumber: number) => boolean;
+    limitB: (pageNumber: number) => boolean;
+    toggle: (index: number) => void;
+    viewSearchInput: (index: number) => boolean;
+    changeColorAsc: (index: number) => "var(--lavendar-grey)" | "var(--accent)" | "transparent";
+    changeColorDesc: (index: number) => "var(--lavendar-grey)" | "var(--accent)" | "transparent";
+    greyBG: (index: number) => boolean | undefined;
+    isOdd: (contIndex: number) => boolean;
+    fillTable: import("vue").ComputedRef<never[]>;
+    finalTable: import("vue").ComputedRef<any>;
+    resultCount: import("vue").ComputedRef<any>;
+    totalPages: import("vue").ComputedRef<number>;
+    getPlaceHolder: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    heads: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    contents: {
+        type: {
+            (arrayLength: number): Object[];
+            (...items: Object[]): Object[];
+            new (arrayLength: number): Object[];
+            new (...items: Object[]): Object[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+        default: () => {
+            values: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+                from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+                from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+                of<T_4>(...items: T_4[]): T_4[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+        }[];
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    sort: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    search: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchColumns: {
+        type: {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: null;
+    };
+    columnType: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    columnStyle: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    tooltipHeader: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    searchFullWord: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    toggleDisplay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagesPosition: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataValues: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    loadingData: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loaderType: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    sort: boolean;
+    search: boolean;
+    contents: Object[];
+    pageSize: number;
+    searchColumns: number[];
+    columnType: string[];
+    columnStyle: Record<string, any>;
+    tooltipHeader: string[];
+    searchFullWord: boolean;
+    toggleDisplay: boolean;
+    pagesPosition: string;
+    noDataValues: unknown[];
+    loadingData: boolean;
+    loaderType: string;
+}, {}>;
 export default _default;

package/dist/runtime/components/argTags.vue

@@ -2,20 +2,30 @@
   <client-only><arg-style /></client-only>
   <div :class="`oip_tag is_${setStyle} have_close_${haveClose}`">
     <slot></slot>
-    <arg-icon v-if="haveClose" name="X" size="14"></arg-icon>
+    <arg-icon v-if="haveClose" name="X" size="14" @click="close()"></arg-icon>
   </div>
 </template>
+
 <script>
-export default {
-  name: "argTags"
-};
-</script>
-<script setup lang="ts">
+import {
+  defineComponent
+} from "vue";
 import argIcon from "./argIcon.vue";
-import { onMounted, ref, computed, defineProps, defineEmits } from "vue";
-const props = defineProps({
-  setStyle: { type: String, default: "primary" },
-  haveClose: { type: Boolean, default: false },
+import argStyle from "./argStyle.vue";
+export default defineComponent({
+  name: "argTags",
+  components: { argIcon, argStyle },
+  props: {
+    setStyle: { type: String, default: "primary" },
+    haveClose: { type: Boolean, default: false }
+  },
+  emits: ["onClose"],
+  setup(props, { emit }) {
+    function close() {
+      emit("onClose");
+    }
+    return { close };
+  }
 });
 </script>
 

package/dist/runtime/components/argTags.vue.d.ts

@@ -1,4 +1,27 @@
-declare const _default: {
-    name: string;
-};
+declare const _default: import("vue").DefineComponent<{
+    setStyle: {
+        type: StringConstructor;
+        default: string;
+    };
+    haveClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    close: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "onClose"[], "onClose", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    setStyle: {
+        type: StringConstructor;
+        default: string;
+    };
+    haveClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onOnClose?: ((...args: any[]) => any) | undefined;
+}, {
+    setStyle: string;
+    haveClose: boolean;
+}, {}>;
 export default _default;

package/dist/runtime/components/argTekkareLoader.vue

@@ -24,9 +24,12 @@
   </div>
 </template>
 <script>
-export default {
+import {
+  defineComponent
+} from "vue";
+export default defineComponent({
   name: "argTekkareLoader"
-};
+});
 </script>
 <style scoped>
 .tekkare_loader_container {

package/dist/runtime/components/argTekkareLoader.vue.d.ts

@@ -1,4 +1,2 @@
-declare const _default: {
-    name: string;
-};
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/runtime/components/argTooltip.vue

@@ -13,17 +13,17 @@
   </div>
 </template>
 <script>
-export default {
-  name: "argTooltip"
-};
-</script>
-<script setup lang="ts">
-import { onMounted, ref, computed, defineProps, defineEmits } from "vue";
-const props = defineProps({
-  tooltipText: { type: String, required: true },
-  dir: { type: String, default: "top" },
-  disable: { type: Boolean, default: false },
-  sideLimit: { type: Boolean, default: false },
+import {
+  defineComponent
+} from "vue";
+export default defineComponent({
+  name: "argTooltip",
+  props: {
+    tooltipText: { type: String, required: true },
+    dir: { type: String, default: "top" },
+    disable: { type: Boolean, default: false },
+    sideLimit: { type: Boolean, default: false }
+  }
 });
 </script>
 

package/dist/runtime/components/argTooltip.vue.d.ts

@@ -1,4 +1,40 @@
-declare const _default: {
-    name: string;
-};
+declare const _default: import("vue").DefineComponent<{
+    tooltipText: {
+        type: StringConstructor;
+        required: true;
+    };
+    dir: {
+        type: StringConstructor;
+        default: string;
+    };
+    disable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sideLimit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    tooltipText: {
+        type: StringConstructor;
+        required: true;
+    };
+    dir: {
+        type: StringConstructor;
+        default: string;
+    };
+    disable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sideLimit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disable: boolean;
+    dir: string;
+    sideLimit: boolean;
+}, {}>;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/auriga",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Aurgia is a UI kit developped by Tekkare",
   "license": "MIT",
   "type": "module",
@@ -24,7 +24,10 @@
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
     "test": "vitest run",
-    "test:watch": "vitest watch"
+    "test:watch": "vitest watch",
+    "storybook": "npm --prefix ./docs run storybook -- --port 6006",
+    "chromatic": "npm --prefix ./docs run chromatic",
+    "patch": "nuxt-module-build && npm version patch && npm publish"
   },
   "dependencies": {
     "@nuxt/kit": "^3.7.3"