@aziontech/webkit 1.6.0 → 1.7.1

package/src/core/primevue/datatable/datatable.vue.d.ts

@@ -0,0 +1,311 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    dataKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    first: {
+        type: NumberConstructor;
+        default: number;
+    };
+    totalRecords: {
+        type: NumberConstructor;
+        default: number;
+    };
+    paginator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sortField: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sortOrder: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultSortOrder: {
+        type: NumberConstructor;
+        default: number;
+    };
+    multiSortMeta: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    sortMode: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    removableSort: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filters: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    filterDisplay: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    globalFilterFields: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    selection: {
+        type: (ObjectConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    selectionMode: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    compareSelectionBy: {
+        type: StringConstructor;
+        default: string;
+    };
+    metaKeySelection: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contextMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contextMenuSelection: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    rowHover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    sort: (...args: any[]) => void;
+    filter: (...args: any[]) => void;
+    "update:selection": (...args: any[]) => void;
+    page: (...args: any[]) => void;
+    "update:first": (...args: any[]) => void;
+    "update:rows": (...args: any[]) => void;
+    "update:sortField": (...args: any[]) => void;
+    "update:sortOrder": (...args: any[]) => void;
+    "update:multiSortMeta": (...args: any[]) => void;
+    "update:contextMenuSelection": (...args: any[]) => void;
+    "update:filters": (...args: any[]) => void;
+    "row-select": (...args: any[]) => void;
+    "row-unselect": (...args: any[]) => void;
+    "row-select-all": (...args: any[]) => void;
+    "row-unselect-all": (...args: any[]) => void;
+    "row-click": (...args: any[]) => void;
+    "row-dblclick": (...args: any[]) => void;
+    "row-contextmenu": (...args: any[]) => void;
+    "row-expand": (...args: any[]) => void;
+    "row-collapse": (...args: any[]) => void;
+    "column-resize-end": (...args: any[]) => void;
+    "column-reorder": (...args: any[]) => void;
+    "row-reorder": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    dataKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    first: {
+        type: NumberConstructor;
+        default: number;
+    };
+    totalRecords: {
+        type: NumberConstructor;
+        default: number;
+    };
+    paginator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    sortField: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sortOrder: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultSortOrder: {
+        type: NumberConstructor;
+        default: number;
+    };
+    multiSortMeta: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    sortMode: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    removableSort: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filters: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    filterDisplay: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    globalFilterFields: {
+        type: ArrayConstructor;
+        default: undefined;
+    };
+    selection: {
+        type: (ObjectConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    selectionMode: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    compareSelectionBy: {
+        type: StringConstructor;
+        default: string;
+    };
+    metaKeySelection: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contextMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contextMenuSelection: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    rowHover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onSort?: ((...args: any[]) => any) | undefined;
+    onFilter?: ((...args: any[]) => any) | undefined;
+    "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
+    onPage?: ((...args: any[]) => any) | undefined;
+    "onUpdate:first"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:rows"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:sortField"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:sortOrder"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:multiSortMeta"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:contextMenuSelection"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:filters"?: ((...args: any[]) => any) | undefined;
+    "onRow-select"?: ((...args: any[]) => any) | undefined;
+    "onRow-unselect"?: ((...args: any[]) => any) | undefined;
+    "onRow-select-all"?: ((...args: any[]) => any) | undefined;
+    "onRow-unselect-all"?: ((...args: any[]) => any) | undefined;
+    "onRow-click"?: ((...args: any[]) => any) | undefined;
+    "onRow-dblclick"?: ((...args: any[]) => any) | undefined;
+    "onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
+    "onRow-expand"?: ((...args: any[]) => any) | undefined;
+    "onRow-collapse"?: ((...args: any[]) => any) | undefined;
+    "onColumn-resize-end"?: ((...args: any[]) => any) | undefined;
+    "onColumn-reorder"?: ((...args: any[]) => any) | undefined;
+    "onRow-reorder"?: ((...args: any[]) => any) | undefined;
+}>, {
+    class: string;
+    value: unknown[];
+    dataKey: string;
+    filters: Record<string, any>;
+    selection: Record<string, any> | unknown[];
+    metaKeySelection: boolean;
+    rows: number;
+    lazy: boolean;
+    first: number;
+    totalRecords: number;
+    paginator: boolean;
+    sortField: string;
+    sortOrder: number;
+    defaultSortOrder: number;
+    multiSortMeta: unknown[];
+    sortMode: string;
+    removableSort: boolean;
+    filterDisplay: string;
+    globalFilterFields: unknown[];
+    selectionMode: string;
+    compareSelectionBy: string;
+    contextMenu: boolean;
+    contextMenuSelection: Record<string, any>;
+    rowHover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    header?: ((props: {}) => any) | undefined;
+} & {
+    footer?: ((props: {}) => any) | undefined;
+} & {
+    paginatorstart?: ((props: {}) => any) | undefined;
+} & {
+    paginatorend?: ((props: {}) => any) | undefined;
+} & {
+    empty?: ((props: {}) => any) | undefined;
+} & {
+    groupheader?: ((props: {
+        data: any;
+        index: number;
+    }) => any) | undefined;
+} & {
+    groupfooter?: ((props: {
+        data: any;
+        index: number;
+    }) => any) | undefined;
+} & {
+    expansion?: ((props: {
+        data: any;
+        index: number;
+    }) => any) | undefined;
+} & {
+    loading?: ((props: {}) => any) | undefined;
+} & {
+    default?: ((props: {}) => any) | undefined;
+};
+//# sourceMappingURL=datatable.vue.d.ts.map

package/src/core/primevue/datatable/datatable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datatable.vue.d.ts","sourceRoot":"","sources":["datatable.vue"],"names":[],"mappings":"wBA+tBqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AA1GzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAuGG"}

package/src/core/primevue/datatable/package.json

@@ -0,0 +1 @@
+{"main": "./datatable.vue", "module": "./datatable.vue", "browser": {"./sfc": "./datatable.vue"}, "sideEffects": ["*.vue"]}

package/src/core/primevue/dialog/dialog.vue

@@ -0,0 +1,86 @@
+<script setup>
+import Dialog from 'primevue/dialog'
+
+defineOptions({ name: 'Dialog' })
+
+const props = defineProps({
+  visible: {
+    type: Boolean,
+    default: false
+  },
+  header: {
+    type: String,
+    default: undefined
+  },
+  modal: {
+    type: Boolean,
+    default: false
+  },
+  contentClass: {
+    type: String,
+    default: undefined
+  },
+  rtl: {
+    type: Boolean,
+    default: false
+  },
+  closable: {
+    type: Boolean,
+    default: true
+  },
+  closeOnEscape: {
+    type: Boolean,
+    default: true
+  },
+  showHeader: {
+    type: Boolean,
+    default: true
+  },
+  breakpoints: {
+    type: Object,
+    default: undefined
+  },
+  class: {
+    type: String,
+    default: ''
+  }
+})
+
+const emit = defineEmits(['update:visible', 'hide', 'show', 'maximize', 'unmaximize'])
+</script>
+
+<template>
+  <Dialog
+    :visible="props.visible"
+    :header="props.header"
+    :modal="props.modal"
+    :contentClass="props.contentClass"
+    :rtl="props.rtl"
+    :closable="props.closable"
+    :closeOnEscape="props.closeOnEscape"
+    :showHeader="props.showHeader"
+    :breakpoints="props.breakpoints"
+    :class="props.class"
+    @update:visible="emit('update:visible', $event)"
+    @hide="emit('hide')"
+    @show="emit('show')"
+    @maximize="emit('maximize', $event)"
+    @unmaximize="emit('unmaximize', $event)"
+  >
+    <template v-if="$slots.header" #header>
+      <slot name="header" />
+    </template>
+    <template v-if="$slots.default" #default>
+      <slot />
+    </template>
+    <template v-if="$slots.footer" #footer>
+      <slot name="footer" />
+    </template>
+    <template v-if="$slots.maximizeicon" #maximizeicon>
+      <slot name="maximizeicon" />
+    </template>
+    <template v-if="$slots.closeicon" #closeicon>
+      <slot name="closeicon" />
+    </template>
+  </Dialog>
+</template>

package/src/core/primevue/dialog/dialog.vue.d.ts

@@ -0,0 +1,124 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    header: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentClass: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rtl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    breakpoints: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    show: (...args: any[]) => void;
+    hide: (...args: any[]) => void;
+    "update:visible": (...args: any[]) => void;
+    maximize: (...args: any[]) => void;
+    unmaximize: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    header: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentClass: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rtl: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    breakpoints: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onShow?: ((...args: any[]) => any) | undefined;
+    onHide?: ((...args: any[]) => any) | undefined;
+    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+    onMaximize?: ((...args: any[]) => any) | undefined;
+    onUnmaximize?: ((...args: any[]) => any) | undefined;
+}>, {
+    class: string;
+    header: string;
+    contentClass: string;
+    visible: boolean;
+    modal: boolean;
+    rtl: boolean;
+    closable: boolean;
+    closeOnEscape: boolean;
+    showHeader: boolean;
+    breakpoints: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    header?: ((props: {}) => any) | undefined;
+} & {
+    default?: ((props: {}) => any) | undefined;
+} & {
+    footer?: ((props: {}) => any) | undefined;
+} & {
+    maximizeicon?: ((props: {}) => any) | undefined;
+} & {
+    closeicon?: ((props: {}) => any) | undefined;
+};
+//# sourceMappingURL=dialog.vue.d.ts.map

package/src/core/primevue/dialog/dialog.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.vue.d.ts","sourceRoot":"","sources":["dialog.vue"],"names":[],"mappings":"wBAoVqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AA/CzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EA4CG"}

package/src/core/primevue/dialog/package.json

@@ -0,0 +1 @@
+{"main": "./dialog.vue", "module": "./dialog.vue", "browser": {"./sfc": "./dialog.vue"}, "sideEffects": ["*.vue"]}

package/src/core/primevue/divider/divider.vue

@@ -0,0 +1,40 @@
+<script setup>
+import Divider from 'primevue/divider'
+
+defineOptions({ name: 'Divider' })
+
+const props = defineProps({
+  align: {
+    type: String,
+    default: undefined,
+    validator: (val) => ['left', 'center', 'right'].includes(val)
+  },
+  layout: {
+    type: String,
+    default: 'horizontal',
+    validator: (val) => ['horizontal', 'vertical'].includes(val)
+  },
+  type: {
+    type: String,
+    default: 'solid',
+    validator: (val) => ['solid', 'dashed', 'dotted'].includes(val)
+  },
+  class: {
+    type: String,
+    default: ''
+  }
+})
+</script>
+
+<template>
+  <Divider
+    :align="props.align"
+    :layout="props.layout"
+    :type="props.type"
+    :class="props.class"
+  >
+    <template v-if="$slots.default" #default>
+      <slot />
+    </template>
+  </Divider>
+</template>

package/src/core/primevue/divider/divider.vue.d.ts

@@ -0,0 +1,56 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    align: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    layout: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    align: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (val: unknown) => boolean;
+    };
+    layout: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    type: string;
+    align: string;
+    layout: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};
+//# sourceMappingURL=divider.vue.d.ts.map

package/src/core/primevue/divider/divider.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divider.vue.d.ts","sourceRoot":"","sources":["divider.vue"],"names":[],"mappings":"wBAmJqB,OAAO,YAAY;;AADxC,4BAA2B,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;qBAEtD,CAAC,EAAE,CAAC;;;AAzBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAsBG"}

package/src/core/primevue/divider/package.json

@@ -0,0 +1 @@
+{"main": "./divider.vue", "module": "./divider.vue", "browser": {"./sfc": "./divider.vue"}, "sideEffects": ["*.vue"]}

package/src/core/primevue/inline-message/inline-message.vue

@@ -0,0 +1,31 @@
+<script setup>
+import InlineMessage from 'primevue/inlinemessage'
+
+defineOptions({ name: 'InlineMessage' })
+
+const props = defineProps({
+  severity: {
+    type: String,
+    default: 'error',
+    validator: (val) => ['success', 'info', 'warn', 'error'].includes(val)
+  },
+  icon: {
+    type: String,
+    default: undefined
+  },
+  class: {
+    type: String,
+    default: ''
+  }
+})
+</script>
+
+<template>
+  <InlineMessage
+    :severity="props.severity"
+    :icon="props.icon"
+    :class="props.class"
+  >
+    <slot />
+  </InlineMessage>
+</template>