@katlux/toolkit 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/runtime/components/KDatatable/KDatatable.global.vue.d.ts

@@ -0,0 +1,23 @@
+import { ADataProvider } from '@katlux/providers';
+import type { IKDatatableAction } from '@katlux/providers';
+interface Props {
+    dataProvider: ADataProvider;
+    visibleFields: Array<string> | null;
+    rowActions?: Array<IKDatatableAction>;
+    bulkActions?: Array<IKDatatableAction>;
+    cellSlots?: Record<string, any>;
+    headerSlots?: Record<string, any>;
+    columnHeaders?: Record<string, string>;
+    columnWidths?: Record<string, string>;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    bulkActions: Array<IKDatatableAction>;
+    visibleFields: Array<string> | null;
+    rowActions: Array<IKDatatableAction>;
+    cellSlots: Record<string, any>;
+    headerSlots: Record<string, any>;
+    columnHeaders: Record<string, string>;
+    columnWidths: Record<string, string>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDatatable/KDatatable.logic.js

@@ -0,0 +1,19 @@
+import { watch } from "vue";
+export const KDatatableDefaultProps = {
+  visibleFields: null
+};
+export function useKDatatableLogic(props) {
+  const selectedRows = props.dataProvider.selectedRows;
+  const selectAll = props.dataProvider.selectAll;
+  watch(selectAll, (newVal) => {
+    if (newVal === false) {
+      selectedRows.value = [];
+    } else {
+      selectedRows.value = [...props.dataProvider.pageData.value || []];
+    }
+  });
+  return {
+    selectedRows,
+    selectAll
+  };
+}

package/dist/runtime/components/KDatePicker/KDatePicker.global.d.vue.ts

@@ -0,0 +1,42 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    day: string | Date;
+    format: string;
+    calendarDefinedDays: any;
+    calendarMarkedDays: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDatePicker/KDatePicker.global.vue

@@ -0,0 +1,45 @@
+<script setup>
+import { useKDatePickerLogic, KDatePickerDefaultProps } from "./KDatePicker.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KDatePickerDefault from "../../presets/default/components/KDatePicker/KDatePicker.vue";
+const props = defineProps(KDatePickerDefaultProps);
+const {
+  _date,
+  maskedModel,
+  calendarShow,
+  calendarDay,
+  textboxClicked,
+  dateSelected
+} = useKDatePickerLogic(props);
+const presetComponent = usePresetComponent("KDatePicker", KDatePickerDefault);
+const templateProps = computed(() => ({
+  maskedModel: maskedModel.value,
+  calendarShow: calendarShow.value,
+  _date: _date.value,
+  calendarDay: calendarDay.value,
+  format: props.format,
+  calendarDefinedDays: props.calendarDefinedDays,
+  calendarMarkedDays: props.calendarMarkedDays,
+  textboxClicked,
+  dateSelected: handleDateSelected
+}));
+const updateMaskedModel = (val) => {
+  maskedModel.value = val;
+};
+const updateCalendarShow = (val) => {
+  calendarShow.value = val;
+};
+const handleDateSelected = (date) => {
+  dateSelected(date);
+};
+</script>
+
+<template lang="pug">
+component(
+	:is="presetComponent" 
+	v-bind="templateProps"
+	@update:maskedModel="updateMaskedModel" 
+	@update:calendarShow="updateCalendarShow"
+)
+</template>

package/dist/runtime/components/KDatePicker/KDatePicker.global.vue.d.ts

@@ -0,0 +1,42 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    day: string | Date;
+    format: string;
+    calendarDefinedDays: any;
+    calendarMarkedDays: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDatePicker/KDatePicker.logic.d.ts

@@ -0,0 +1,33 @@
+import type { IMarkedDay, IDefinedDay } from '@katlux/toolkit/components/KCalendar/types.ts';
+export interface KDatePickerProps {
+    format: string;
+    day?: Date | string;
+    calendarDefinedDays: IDefinedDay[];
+    calendarMarkedDays: IMarkedDay[];
+}
+export declare const KDatePickerDefaultProps: {
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+};
+export declare function useKDatePickerLogic(props: KDatePickerProps): {
+    _date: import("vue").Ref<string | Date, string | Date>;
+    maskedModel: import("vue").Ref<string, string>;
+    calendarShow: import("vue").Ref<boolean, boolean>;
+    calendarDay: import("vue").ComputedRef<string | Date>;
+    textboxClicked: () => void;
+    dateSelected: (date: Date) => void;
+};

package/dist/runtime/components/KDatePicker/KDatePicker.logic.js

@@ -0,0 +1,63 @@
+import { ref, onMounted, computed } from "vue";
+export const KDatePickerDefaultProps = {
+  format: {
+    type: String,
+    default: "MM-DD-YYYY"
+  },
+  day: {
+    type: [Date, String],
+    default: void 0
+  },
+  calendarDefinedDays: {
+    type: Array,
+    default: () => []
+  },
+  calendarMarkedDays: {
+    type: Array,
+    default: () => []
+  }
+};
+export function useKDatePickerLogic(props) {
+  const _date = ref("");
+  const maskedModel = ref("");
+  const calendarShow = ref(false);
+  const textboxClicked = () => {
+    calendarShow.value = true;
+  };
+  const dateSelected = (date) => {
+    console.log("Date selected:", date);
+    _date.value = date;
+    const formatted = formatDate(date);
+    console.log("Formatted date:", formatted);
+    maskedModel.value = formatted;
+    console.log("maskedModel.value after update:", maskedModel.value);
+    calendarShow.value = false;
+  };
+  const formatDate = (date) => {
+    const day = date.getDate().toString().padStart(2, "0");
+    const month = (date.getMonth() + 1).toString().padStart(2, "0");
+    const year = date.getFullYear();
+    let formattedDate = props.format;
+    formattedDate = formattedDate.replace("DD", day);
+    formattedDate = formattedDate.replace("MM", month);
+    formattedDate = formattedDate.replace("YYYY", year.toString());
+    return formattedDate;
+  };
+  onMounted(() => {
+    maskedModel.value = _date.value.toString();
+  });
+  const calendarDay = computed(() => {
+    if (props.day) {
+      return props.day;
+    }
+    return /* @__PURE__ */ new Date();
+  });
+  return {
+    _date,
+    maskedModel,
+    calendarShow,
+    calendarDay,
+    textboxClicked,
+    dateSelected
+  };
+}

package/dist/runtime/components/KDateTimePicker/KDateTimePicker.global.d.vue.ts

@@ -0,0 +1,60 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    timeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    timeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    day: string | Date;
+    format: string;
+    calendarDefinedDays: any;
+    calendarMarkedDays: any;
+    timeFormat: string;
+    timeStep: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDateTimePicker/KDateTimePicker.global.vue

@@ -0,0 +1,48 @@
+<script setup>
+import { useKDateTimePickerLogic, KDateTimePickerDefaultProps } from "./KDateTimePicker.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KDateTimePickerDefault from "../../presets/default/components/KDateTimePicker/KDateTimePicker.vue";
+const props = defineProps(KDateTimePickerDefaultProps);
+const {
+  _date,
+  _time,
+  maskedModel,
+  calendarShow,
+  calendarDay,
+  textboxClicked,
+  dateSelected,
+  timeSelected
+} = useKDateTimePickerLogic(props);
+const presetComponent = usePresetComponent("KDateTimePicker", KDateTimePickerDefault);
+const templateProps = computed(() => ({
+  maskedModel: maskedModel.value,
+  calendarShow: calendarShow.value,
+  _date: _date.value,
+  _time: _time.value,
+  calendarDay: calendarDay.value,
+  format: props.format,
+  timeFormat: props.timeFormat,
+  timeStep: props.timeStep,
+  calendarDefinedDays: props.calendarDefinedDays,
+  calendarMarkedDays: props.calendarMarkedDays,
+  textboxClicked,
+  dateSelected,
+  timeSelected
+}));
+const updateMaskedModel = (val) => {
+  maskedModel.value = val;
+};
+const updateCalendarShow = (val) => {
+  calendarShow.value = val;
+};
+</script>
+
+<template lang="pug">
+component(
+	:is="presetComponent" 
+	v-bind="templateProps"
+	@update:maskedModel="updateMaskedModel" 
+	@update:calendarShow="updateCalendarShow"
+)
+</template>

package/dist/runtime/components/KDateTimePicker/KDateTimePicker.global.vue.d.ts

@@ -0,0 +1,60 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    timeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    timeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    day: string | Date;
+    format: string;
+    calendarDefinedDays: any;
+    calendarMarkedDays: any;
+    timeFormat: string;
+    timeStep: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDateTimePicker/KDateTimePicker.logic.d.ts

@@ -0,0 +1,45 @@
+import type { IMarkedDay, IDefinedDay } from '@katlux/toolkit/components/KCalendar/types.ts';
+export interface KDateTimePickerProps {
+    format?: string;
+    timeFormat?: string;
+    day?: Date | string;
+    timeStep?: number;
+    calendarDefinedDays?: IDefinedDay[];
+    calendarMarkedDays?: IMarkedDay[];
+}
+export declare const KDateTimePickerDefaultProps: {
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: {
+        type: StringConstructor;
+        default: string;
+    };
+    day: {
+        type: (DateConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    timeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    calendarDefinedDays: {
+        type: PropType<IDefinedDay[]>;
+        default: () => never[];
+    };
+    calendarMarkedDays: {
+        type: PropType<IMarkedDay[]>;
+        default: () => never[];
+    };
+};
+export declare function useKDateTimePickerLogic(props: KDateTimePickerProps): {
+    _date: import("vue").Ref<string | Date, string | Date>;
+    _time: import("vue").Ref<string, string>;
+    maskedModel: import("vue").Ref<string, string>;
+    calendarShow: import("vue").Ref<boolean, boolean>;
+    calendarDay: import("vue").ComputedRef<string | Date>;
+    textboxClicked: () => void;
+    dateSelected: (date: Date) => void;
+    timeSelected: (time: string) => void;
+};

package/dist/runtime/components/KDateTimePicker/KDateTimePicker.logic.js

@@ -0,0 +1,77 @@
+import { ref, computed } from "vue";
+export const KDateTimePickerDefaultProps = {
+  format: {
+    type: String,
+    default: "MM-DD-YYYY HH:mm"
+  },
+  timeFormat: {
+    type: String,
+    default: "HH:mm"
+  },
+  day: {
+    type: [Date, String],
+    default: void 0
+  },
+  timeStep: {
+    type: Number,
+    default: 30
+  },
+  calendarDefinedDays: {
+    type: Array,
+    default: () => []
+  },
+  calendarMarkedDays: {
+    type: Array,
+    default: () => []
+  }
+};
+export function useKDateTimePickerLogic(props) {
+  const _date = ref("");
+  const _time = ref("");
+  const maskedModel = ref("");
+  const calendarShow = ref(false);
+  const textboxClicked = () => {
+    calendarShow.value = true;
+  };
+  const dateSelected = (date) => {
+    _date.value = date;
+    updateMaskedModel();
+  };
+  const timeSelected = (time) => {
+    _time.value = time;
+    updateMaskedModel();
+  };
+  const updateMaskedModel = () => {
+    if (_date.value && _time.value) {
+      const dateStr = formatDate(_date.value);
+      maskedModel.value = `${dateStr} ${_time.value}`;
+    }
+  };
+  const formatDate = (date) => {
+    const day = date.getDate().toString().padStart(2, "0");
+    const month = (date.getMonth() + 1).toString().padStart(2, "0");
+    const year = date.getFullYear();
+    const dateFormat = props.format?.split(" ")[0] || "MM-DD-YYYY";
+    let formattedDate = dateFormat;
+    formattedDate = formattedDate.replace("DD", day);
+    formattedDate = formattedDate.replace("MM", month);
+    formattedDate = formattedDate.replace("YYYY", year.toString());
+    return formattedDate;
+  };
+  const calendarDay = computed(() => {
+    if (props.day) {
+      return props.day;
+    }
+    return /* @__PURE__ */ new Date();
+  });
+  return {
+    _date,
+    _time,
+    maskedModel,
+    calendarShow,
+    calendarDay,
+    textboxClicked,
+    dateSelected,
+    timeSelected
+  };
+}

package/dist/runtime/components/KDropdown/KDropdown.global.d.vue.ts

@@ -0,0 +1,28 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:isOpen": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
+}>, {
+    isOpen: boolean;
+    fullWidth: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDropdown/KDropdown.global.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { useKDropdownLogic, KDropdownDefaultProps } from "./KDropdown.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KDropdownDefault from "../../presets/default/components/KDropdown/KDropdown.vue";
+const props = defineProps(KDropdownDefaultProps);
+const emit = defineEmits(["update:isOpen"]);
+const { open, clickoutside } = useKDropdownLogic(props, emit);
+const presetComponent = usePresetComponent("KDropdown", KDropdownDefault);
+const templateProps = computed(() => ({
+  open: open.value,
+  fullWidth: props.fullWidth,
+  clickoutside
+}));
+</script>
+
+<template lang="pug">
+component(:is="presetComponent" v-bind="templateProps")
+	template(v-for="(_, slot) in $slots" #[slot]="scope")
+		slot(:name="slot" v-bind="scope")
+</template>

package/dist/runtime/components/KDropdown/KDropdown.global.vue.d.ts

@@ -0,0 +1,28 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:isOpen": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
+}>, {
+    isOpen: boolean;
+    fullWidth: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KDropdown/KDropdown.logic.d.ts

@@ -0,0 +1,21 @@
+export interface KDropdownProps {
+    isOpen: boolean;
+    fullWidth: boolean;
+}
+export interface KDropdownEmits {
+    (e: 'update:isOpen', value: boolean): void;
+}
+export declare const KDropdownDefaultProps: {
+    isOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare function useKDropdownLogic(props: KDropdownProps, emit: KDropdownEmits): {
+    open: import("vue").Ref<boolean, boolean>;
+    clickoutside: () => void;
+};