@ramathibodi/nuxt-commons 0.1.21 → 0.1.23

package/dist/runtime/composables/{graphqlModelOperation.mjs → graphqlModelOperation.js}

@@ -13,8 +13,7 @@ export function useGraphqlModelOperation(props) {
   const operationCreate = computed(() => {
     if (props.operationCreate) {
       if (typeof props.operationCreate === "string") {
-        if (graphqlOperation[props.operationCreate])
-          return graphqlOperation[props.operationCreate];
+        if (graphqlOperation[props.operationCreate]) return graphqlOperation[props.operationCreate];
       } else {
         return props.operationCreate;
       }
@@ -24,8 +23,7 @@ export function useGraphqlModelOperation(props) {
   const operationUpdate = computed(() => {
     if (props.operationUpdate) {
       if (typeof props.operationUpdate === "string") {
-        if (graphqlOperation[props.operationUpdate])
-          return graphqlOperation[props.operationUpdate];
+        if (graphqlOperation[props.operationUpdate]) return graphqlOperation[props.operationUpdate];
       } else {
         return props.operationUpdate;
       }
@@ -35,8 +33,7 @@ export function useGraphqlModelOperation(props) {
   const operationDelete = computed(() => {
     if (props.operationDelete) {
       if (typeof props.operationDelete === "string") {
-        if (graphqlOperation[props.operationDelete])
-          return graphqlOperation[props.operationDelete];
+        if (graphqlOperation[props.operationDelete]) return graphqlOperation[props.operationDelete];
       } else {
         return props.operationDelete;
       }
@@ -46,8 +43,7 @@ export function useGraphqlModelOperation(props) {
   const operationRead = computed(() => {
     if (props.operationRead) {
       if (typeof props.operationRead === "string") {
-        if (graphqlOperation[props.operationRead])
-          return graphqlOperation[props.operationRead];
+        if (graphqlOperation[props.operationRead]) return graphqlOperation[props.operationRead];
       } else {
         return props.operationRead;
       }
@@ -57,8 +53,7 @@ export function useGraphqlModelOperation(props) {
   const operationReadPageable = computed(() => {
     if (props.operationReadPageable) {
       if (typeof props.operationReadPageable === "string") {
-        if (graphqlOperation[props.operationReadPageable])
-          return graphqlOperation[props.operationReadPageable];
+        if (graphqlOperation[props.operationReadPageable]) return graphqlOperation[props.operationReadPageable];
       } else {
         return props.operationReadPageable;
       }
@@ -68,8 +63,7 @@ export function useGraphqlModelOperation(props) {
   const operationSearch = computed(() => {
     if (props.operationSearch) {
       if (typeof props.operationSearch === "string") {
-        if (graphqlOperation[props.operationSearch])
-          return graphqlOperation[props.operationSearch];
+        if (graphqlOperation[props.operationSearch]) return graphqlOperation[props.operationSearch];
       } else {
         return props.operationSearch;
       }

package/dist/runtime/composables/graphqlOperation.d.ts

@@ -1,5 +1,5 @@
-import { type ClassConstructor } from '../utils/object';
-import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation';
+import { type ClassConstructor } from '../utils/object.js';
+import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation.js';
 export declare function buildFields(operationFields: graphqlTypeObject, fields?: Array<string | Object> | ClassConstructor<any>, depth?: number): Array<string | Object>;
 export declare function buildVariables(outputVariables?: graphqlVariable[], inputVariables?: {
     [p: string]: any;

package/dist/runtime/composables/{graphqlOperation.mjs → graphqlOperation.js}

@@ -1,26 +1,19 @@
-import { classAttributes, isClassConstructor } from "../utils/object.mjs";
-import { useGraphQl } from "./graphql.mjs";
+import { classAttributes, isClassConstructor } from "../utils/object.js";
+import { useGraphQl } from "./graphql.js";
 import { graphqlInputType, graphqlOperation, graphqlType, scalarType } from "#imports";
 export function buildFields(operationFields, fields, depth = 0) {
-  if (!operationFields)
-    return [];
-  if (isClassConstructor(fields))
-    fields = classAttributes(fields);
-  if (!fields || fields.length == 0)
-    fields = [...operationFields.fields];
+  if (!operationFields) return [];
+  if (isClassConstructor(fields)) fields = classAttributes(fields);
+  if (!fields || fields.length == 0) fields = [...operationFields.fields];
   if (fields.includes("*")) {
     operationFields.fields.forEach((field) => {
-      if (!fields.includes(field))
-        fields.push(field);
+      if (!fields.includes(field)) fields.push(field);
     });
     fields.splice(fields.indexOf("*"), 1);
   }
-  if (depth > 0)
-    operationFields.relations.forEach((relation) => fields.push(relation.name));
-  if (!fields.includes("timestampField") && operationFields.relations.find((relation) => relation.name == "timestampField"))
-    fields.push("timestampField");
-  if (!fields.includes("userstampField") && operationFields.relations.find((relation) => relation.name == "userstampField"))
-    fields.push("userstampField");
+  if (depth > 0) operationFields.relations.forEach((relation) => fields.push(relation.name));
+  if (!fields.includes("timestampField") && operationFields.relations.find((relation) => relation.name == "timestampField")) fields.push("timestampField");
+  if (!fields.includes("userstampField") && operationFields.relations.find((relation) => relation.name == "userstampField")) fields.push("userstampField");
   return fields.map((field) => {
     if (typeof field == "string" && !operationFields?.fields?.includes(field)) {
       const relationField = operationFields?.relations?.find((relation) => relation.name == field);
@@ -42,8 +35,7 @@ export function buildFields(operationFields, fields, depth = 0) {
   }).filter((field) => !!field);
 }
 export function buildVariables(outputVariables, inputVariables, reject, isRoot = true) {
-  if (!outputVariables)
-    return void 0;
+  if (!outputVariables) return void 0;
   if (inputVariables) {
     outputVariables.map((variable) => {
       if (variable.type && !scalarType.includes(variable.type)) {
@@ -77,8 +69,7 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
   });
   const usedVariables = outputVariables.map((variable) => variable.name);
   const droppedVariable = Object.keys(inputVariables || {}).filter((key) => !usedVariables.includes(key));
-  if (droppedVariable.length > 0)
-    console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
+  if (droppedVariable.length > 0) console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
   return outputVariables.reduce((acc, item) => {
     acc[item.name] = isRoot ? item : item.value;
     return acc;
@@ -89,8 +80,7 @@ export function buildRequiredInputFields(variables, inputField = "input") {
   if (inputVariable) {
     const returnFields = [];
     graphqlInputType[inputVariable.type]?.variables?.forEach((variable) => {
-      if (variable.required)
-        returnFields.push(variable.name);
+      if (variable.required) returnFields.push(variable.name);
     });
     return returnFields;
   } else {
@@ -110,12 +100,9 @@ export function useGraphQlOperation(operationType, operation, fields, variables,
     }
     if (graphqlOperation[operation]?.fields) {
       fields = buildFields(graphqlOperation[operation]?.fields, fields, 0);
-      if (operationType == "Query")
-        useGraphQl().queryPromise(operation, fields, variables, cache).then((result) => resolve(result)).catch((error) => reject(error));
-      else if (operationType == "Mutation")
-        useGraphQl().mutationPromise(operation, fields, variables).then((result) => resolve(result)).catch((error) => reject(error));
-      else
-        reject("Invalid Operation Type");
+      if (operationType == "Query") useGraphQl().queryPromise(operation, fields, variables, cache).then((result) => resolve(result)).catch((error) => reject(error));
+      else if (operationType == "Mutation") useGraphQl().mutationPromise(operation, fields, variables).then((result) => resolve(result)).catch((error) => reject(error));
+      else reject("Invalid Operation Type");
     } else {
       reject("No schema of return data available");
     }

package/dist/runtime/composables/menu.d.ts

@@ -1,6 +1,6 @@
 import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
 import { type RouteRecordNormalized, type RouteRecordRaw } from 'vue-router';
-import { type MenuItem } from '../types/menu';
+import { type MenuItem } from '../types/menu.js';
 export interface MenuProvide {
     menuAll: Ref<MenuItem[]>;
     menuByRoute: ComputedRef<MenuItem[]>;

package/dist/runtime/composables/{menu.mjs → menu.js}

@@ -11,18 +11,18 @@ export function routeToMenuItem(route) {
       icon: menuMeta.icon,
       role: menuMeta.role,
       name: route.name,
+      image: menuMeta.image,
       menuItems: [],
       link: {
         name: route.name
       },
-      active: true
+      active: menuMeta.active != void 0 ? menuMeta.active : true
     };
     if (route.children) {
       const menuItems = new Array();
       for (const children of route.children) {
         const childMenuItem = routeToMenuItem(children);
-        if (childMenuItem)
-          menuItems.push(childMenuItem);
+        if (childMenuItem) menuItems.push(childMenuItem);
         menuItem.menuItems = menuItems;
       }
     }
@@ -37,8 +37,7 @@ export function createMenu() {
     if (paths.length == 2) {
       if (route.path != "/login" && route.path != "/") {
         const menuItem = routeToMenuItem(route);
-        if (menuItem)
-          menuAll.value.push(menuItem);
+        if (menuItem) menuAll.value.push(menuItem);
       }
     }
   }

package/dist/runtime/composables/utils/fuzzy.d.ts

@@ -1,2 +1,2 @@
 import type { MaybeRefOrGetter } from 'vue';
-export declare function useFuzzy(searchTerm: MaybeRefOrGetter<string>, items: MaybeRefOrGetter<any[]>, fieldName: MaybeRefOrGetter<string[]>, options?: MaybeRefOrGetter<Record<string, any>>): import("vue").ComputedRef<Fuse.FuseResult<DataItem>[]>;
+export declare function useFuzzy(searchTerm: MaybeRefOrGetter<string>, items: MaybeRefOrGetter<any[]>, fieldName: MaybeRefOrGetter<string[]>, options?: MaybeRefOrGetter<Record<string, any>>): import("vue").ComputedRef<import("fuse.js").FuseResult<any>[]>;

package/dist/runtime/composables/utils/validation.d.ts

@@ -30,5 +30,37 @@ export declare function useRules(): {
         email: (customError?: string) => (value: any) => string | true;
         regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
         idcard: (customError?: string) => (value: any) => string | true;
+    }, {
+        require: (customError?: string) => (value: any) => string | true;
+        requireIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        requireTrue: (customError?: string) => (value: any) => string | true;
+        requireTrueIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        numeric: (customError?: string) => (value: any) => string | true;
+        range: (minValue: number, maxValue: number, customError?: string) => (value: any) => string | true;
+        integer: (customError?: string) => (value: any) => string | true;
+        unique: (data: Array<any> | object, fieldName: string, customError?: string) => (value: any) => string | true;
+        length: (length: number, customError?: string) => (value: any) => string | true;
+        lengthGreater: (length: number, customError?: string) => (value: any) => string | true;
+        lengthLess: (length: number, customError?: string) => (value: any) => string | true;
+        telephone: (customError?: string) => (value: any) => string | true;
+        email: (customError?: string) => (value: any) => string | true;
+        regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
+        idcard: (customError?: string) => (value: any) => string | true;
+    } | {
+        require: (customError?: string) => (value: any) => string | true;
+        requireIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        requireTrue: (customError?: string) => (value: any) => string | true;
+        requireTrueIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        numeric: (customError?: string) => (value: any) => string | true;
+        range: (minValue: number, maxValue: number, customError?: string) => (value: any) => string | true;
+        integer: (customError?: string) => (value: any) => string | true;
+        unique: (data: Array<any> | object, fieldName: string, customError?: string) => (value: any) => string | true;
+        length: (length: number, customError?: string) => (value: any) => string | true;
+        lengthGreater: (length: number, customError?: string) => (value: any) => string | true;
+        lengthLess: (length: number, customError?: string) => (value: any) => string | true;
+        telephone: (customError?: string) => (value: any) => string | true;
+        email: (customError?: string) => (value: any) => string | true;
+        regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
+        idcard: (customError?: string) => (value: any) => string | true;
     }>;
 };

package/dist/runtime/plugins/permission.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/{permission.mjs → permission.js}

@@ -2,8 +2,7 @@ import { defineNuxtPlugin } from "nuxt/app";
 import { useAuthentication } from "#imports";
 export default defineNuxtPlugin(async (nuxtApp) => {
   function permission(permissionId) {
-    if (!permissionId || useAuthentication()?.hasPermission(permissionId) === void 0)
-      return true;
+    if (!permissionId || useAuthentication()?.hasPermission(permissionId) === void 0) return true;
     return useAuthentication()?.hasPermission(permissionId);
   }
   nuxtApp.vueApp.config.globalProperties.$permission = permission;
@@ -15,8 +14,7 @@ export default defineNuxtPlugin(async (nuxtApp) => {
             um();
           });
         }
-        if (el.parentElement)
-          el.parentElement.removeChild(el);
+        if (el.parentElement) el.parentElement.removeChild(el);
       }
     }
   });

package/dist/runtime/types/menu.d.ts

@@ -9,6 +9,8 @@ declare global {
     title: string
     icon: string
     role: string
+    image? : string
+    active? : boolean
   }
 
   interface MenuItem {
@@ -19,6 +21,7 @@ declare global {
     menuItems: Array<MenuItem>
     active: boolean
     name: string
+    image? : string
   }
 }
 

package/dist/runtime/utils/datetime.d.ts

@@ -4,22 +4,220 @@ export type dateFormat = 'tinyDate' | 'monthShortDate' | 'shortDate' | 'longDate
 export type dateTimeFormat = 'tinyDateTime' | 'shortDateTime' | 'longDateTime';
 export declare const Datetime: () => {
     luxonDateTime: DateTime<false>;
-    fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-    fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-    fromISO: (dateTime: string, locale?: supportedLocale) => any;
-    fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-    setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-    toFormat: (format: string, locale?: supportedLocale) => any;
-    toISO: () => any;
-    toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => any;
-    toTinyDate: (locale?: supportedLocale) => any;
-    toMonthShortDate: (locale?: supportedLocale) => any;
-    toShortDate: (locale?: supportedLocale) => any;
-    toLongDate: (locale?: supportedLocale) => any;
-    toTinyDateTime: (locale?: supportedLocale) => any;
-    toShortDateTime: (locale?: supportedLocale) => any;
-    toLongDateTime: (locale?: supportedLocale) => any;
-    now: () => any;
+    fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromISO: (dateTime: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+    toISO: () => null;
+    toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+    toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    now: () => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromISO: (dateTime: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: any;
+    };
 };
 export declare function verifyDateFormat(date: string): string | null;
 export declare function returnVerifyDate(date: string): string | null;

package/dist/runtime/utils/{datetime.mjs → datetime.js}

@@ -2,13 +2,10 @@ import { DateTime } from "luxon";
 export const Datetime = () => ({
   luxonDateTime: DateTime.invalid("Uninitialized"),
   fromString: function(dateTime, formatDate, locale = "EN") {
-    if (!dateTime)
-      return this.setDateTime(DateTime.invalid("No datetime string provided"), locale);
+    if (!dateTime) return this.setDateTime(DateTime.invalid("No datetime string provided"), locale);
     let inputDate = void 0;
-    if (formatDate)
-      inputDate = DateTime.fromFormat(dateTime, formatDate, { locale });
-    if (!inputDate?.isValid)
-      inputDate = DateTime.fromISO(dateTime, { locale });
+    if (formatDate) inputDate = DateTime.fromFormat(dateTime, formatDate, { locale });
+    if (!inputDate?.isValid) inputDate = DateTime.fromISO(dateTime, { locale });
     if (!inputDate?.isValid) {
       const formats = [
         "ddMMyyyy",
@@ -26,18 +23,15 @@ export const Datetime = () => ({
       ];
       for (let i = 0; i < formats.length; ++i) {
         inputDate = DateTime.fromFormat(dateTime, formats[i], { locale });
-        if (inputDate.isValid)
-          break;
+        if (inputDate.isValid) break;
       }
     }
     return this.setDateTime(inputDate, locale);
   },
   fromStringTime: function(time, formatTime, locale = "EN") {
-    if (!time)
-      return this.setDateTime(DateTime.invalid("No datetime string provided"), locale);
+    if (!time) return this.setDateTime(DateTime.invalid("No datetime string provided"), locale);
     let inputTime = void 0;
-    if (formatTime)
-      inputTime = DateTime.fromFormat(time, formatTime, { locale });
+    if (formatTime) inputTime = DateTime.fromFormat(time, formatTime, { locale });
     if (!inputTime?.isValid) {
       const formats = [
         "HHmm",
@@ -49,12 +43,10 @@ export const Datetime = () => ({
       ];
       for (let i = 0; i < formats.length; ++i) {
         inputTime = DateTime.fromFormat(time, formats[i], { locale });
-        if (inputTime.isValid)
-          break;
+        if (inputTime.isValid) break;
       }
     }
-    if (!inputTime?.isValid)
-      inputTime = DateTime.fromISO(time, { locale });
+    if (!inputTime?.isValid) inputTime = DateTime.fromISO(time, { locale });
     return this.setDateTime(inputTime, locale);
   },
   fromISO: function(dateTime, locale = "EN") {
@@ -67,45 +59,31 @@ export const Datetime = () => ({
   },
   setDateTime: function(inputDate, locale = "EN") {
     if (inputDate.isValid) {
-      if (inputDate.year - DateTime.now().year > 300)
-        inputDate = inputDate.set({ year: inputDate.year - 543 });
+      if (inputDate.year - DateTime.now().year > 300) inputDate = inputDate.set({ year: inputDate.year - 543 });
     }
     this.luxonDateTime = inputDate;
-    if (locale == "TH")
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
-    else
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
+    if (locale == "TH") this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
+    else this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
     return this;
   },
   toFormat: function(format, locale = "EN") {
-    if (format == "tinyDate")
-      return this.toTinyDate(locale);
-    if (format == "monthShortDate")
-      return this.toMonthShortDate(locale);
-    if (format == "shortDate")
-      return this.toShortDate(locale);
-    if (format == "longDate")
-      return this.toLongDate(locale);
-    if (format == "tinyDateTime")
-      return this.toTinyDateTime(locale);
-    if (format == "shortDateTime")
-      return this.toShortDateTime(locale);
-    if (format == "longDateTime")
-      return this.toLongDateTime(locale);
-    if (locale == "TH")
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
-    else
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
+    if (format == "tinyDate") return this.toTinyDate(locale);
+    if (format == "monthShortDate") return this.toMonthShortDate(locale);
+    if (format == "shortDate") return this.toShortDate(locale);
+    if (format == "longDate") return this.toLongDate(locale);
+    if (format == "tinyDateTime") return this.toTinyDateTime(locale);
+    if (format == "shortDateTime") return this.toShortDateTime(locale);
+    if (format == "longDateTime") return this.toLongDateTime(locale);
+    if (locale == "TH") this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
+    else this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
     return this.luxonDateTime.toFormat(format);
   },
   toISO: function() {
     return this.luxonDateTime.toISO();
   },
   toLocaleFormat: function(locale, format) {
-    if (locale == "TH")
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
-    else
-      this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
+    if (locale == "TH") this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "buddhist" });
+    else this.luxonDateTime = this.luxonDateTime.setLocale(locale).reconfigure({ outputCalendar: "gregory" });
     return this.luxonDateTime.setLocale(locale).toLocaleString(format);
   },
   toTinyDate: function(locale = "EN") {

package/dist/runtime/utils/{object.mjs → object.js}

@@ -11,8 +11,7 @@ export function classAttributes(cls) {
 export function onlyAttributes(keys, object) {
   const returnObject = cloneDeep(object);
   Object.keys(object).forEach((localKey) => {
-    if (!keys.includes(localKey))
-      delete returnObject[localKey];
+    if (!keys.includes(localKey)) delete returnObject[localKey];
   });
   return returnObject;
 }