@ramathibodi/nuxt-commons 0.1.56 → 0.1.57

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

@@ -0,0 +1,28 @@
+export type Lang = 'TH' | 'EN';
+export type MasterSortBy = 'itemCode' | 'itemValue';
+export interface MasterLikeProps {
+    sortBy?: MasterSortBy;
+    showCode?: boolean;
+    groupKey: string;
+    itemCodes?: string[];
+    lang?: Lang;
+    fields?: Array<string | object>;
+    noDataText?: string;
+    filterText?: string;
+    waitForFilter?: boolean;
+    waitForFilterText?: string;
+    meilisearch?: boolean;
+    cache?: boolean | number;
+}
+export declare function useLookupListMaster(props: MasterLikeProps): {
+    computedModelName: import("vue").ComputedRef<string>;
+    computedModelBy: import("vue").ComputedRef<Record<string, any>>;
+    computedModelSelectedItemBy: import("vue").ComputedRef<{
+        groupKey: string;
+    }>;
+    computedFields: import("vue").ComputedRef<(string | object)[]>;
+    itemTitleField: import("vue").ComputedRef<"itemValue" | "itemValueAlternative">;
+    computedNoDataText: import("vue").ComputedRef<string | undefined>;
+    computedSortBy: import("vue").ComputedRef<string[]>;
+    formatItemTitle: (item: any) => string;
+};

package/dist/runtime/composables/lookupListMaster.js

@@ -0,0 +1,61 @@
+import { computed } from "vue";
+import { union } from "lodash-es";
+export function useLookupListMaster(props) {
+  const computedModelName = computed(() => {
+    let operation = "masterItemByGroupKey";
+    if (props.filterText) operation = "masterItemByGroupKeyAndFilterText";
+    if (props.itemCodes && props.itemCodes.length > 0) operation = "masterItemByGroupKeyAndItemCodeIn";
+    if (props.meilisearch) operation = "masterItemByGroupKeyAndFilterTextAndKeyword";
+    if (props.waitForFilter && !props.filterText) operation = "";
+    return operation;
+  });
+  const computedModelBy = computed(() => {
+    const modelBy = { groupKey: props.groupKey };
+    if (props.filterText) modelBy["filterText"] = props.filterText;
+    if (props.itemCodes && props.itemCodes.length > 0) modelBy["itemCodes"] = props.itemCodes;
+    return modelBy;
+  });
+  const computedModelSelectedItemBy = computed(() => ({ groupKey: props.groupKey }));
+  const computedFields = computed(() => {
+    const extra = [];
+    if (props.filterText) extra.push("filterText");
+    if (props.meilisearch) extra.push("_formatted");
+    return union(["itemCode", "itemValue", "itemValueAlternative"], extra, props.fields || []);
+  });
+  const itemTitleField = computed(() => props.lang === "TH" ? "itemValue" : "itemValueAlternative");
+  const formatItemTitle = (item) => {
+    if (props.meilisearch) {
+      const raw = item.raw?._formatted ?? {};
+      const code = raw?.itemCode;
+      const title = raw?.[itemTitleField.value] ?? raw?.itemValue ?? raw?.itemCode;
+      return (props.showCode ? (code ?? "") + "-" : "") + (title ?? "");
+    } else {
+      const code = item.raw?.itemCode;
+      const title = item.title ?? item.raw?.itemValue ?? item.raw?.itemCode;
+      return (props.showCode ? (code ?? "") + "-" : "") + (title ?? "");
+    }
+  };
+  const computedNoDataText = computed(() => {
+    if (props.waitForFilter && !props.filterText) return props.waitForFilterText;
+    return props.noDataText;
+  });
+  const computedSortBy = computed(() => {
+    if ((props.sortBy ?? "itemValue") === "itemValue") {
+      if (props.showCode) return ["itemCode"];
+      return [itemTitleField.value, "itemValue", "itemCode"];
+    }
+    return [props.sortBy ?? "itemValue"];
+  });
+  return {
+    // for <model-*> props
+    computedModelName,
+    computedModelBy,
+    computedModelSelectedItemBy,
+    computedFields,
+    itemTitleField,
+    computedNoDataText,
+    computedSortBy,
+    // helpers
+    formatItemTitle
+  };
+}

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

@@ -9,8 +9,8 @@ declare global {
     title: string
     icon: string
     role?: string
-    image? : string
-    active? : boolean
+    image?: string
+    active?: boolean
   }
 
   interface MenuItem {
@@ -21,8 +21,11 @@ declare global {
     menuItems: Array<MenuItem>
     active: boolean
     name: string
-    image? : string
+    image?: string
   }
 }
 
-export { MenuMeta, MenuItem }
+export type MenuMeta = globalThis.MenuMeta
+export type MenuItem = globalThis.MenuItem
+
+export {}

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

@@ -0,0 +1 @@
+export declare const joinObject: (obj: any, attribute?: string, separator?: string) => string;

package/dist/runtime/utils/formatter.js

@@ -0,0 +1,19 @@
+import { get } from "lodash-es";
+export const joinObject = (obj, attribute, separator = ",") => {
+  if (!Array.isArray(obj)) {
+    return obj != null ? obj.toString() : "";
+  }
+  return obj.map((item) => {
+    if (item && typeof item === "object") {
+      if (attribute) {
+        const val = get(item, attribute);
+        if (val !== void 0) return val;
+      }
+      if (item.label !== void 0) return item.label;
+      if (item.value !== void 0) return item.value;
+      return item.toString();
+    } else {
+      return item != null ? item.toString() : "";
+    }
+  }).join(separator);
+};

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

@@ -7,3 +7,4 @@ export declare function classAttributes<T extends Record<string, any>>(cls: Clas
 export declare function onlyAttributes(keys: string[], object: Record<string, any>): Record<string, any>;
 export declare function renameAttributes(object: Record<string, any>, mapper: Record<string, string>): Record<string, any>;
 export declare function stableStringify(obj: any): string;
+export declare function safeParseJSONDeep<T = any>(input: T, childKeys?: string[], keysToParse?: string[]): T;

package/dist/runtime/utils/object.js

@@ -1,4 +1,4 @@
-import { cloneDeep } from "lodash-es";
+import { cloneDeep, isArray, isString, isPlainObject, forOwn } from "lodash-es";
 export function isClassConstructor(arg) {
   return typeof arg === "function" && /^class\s/.test(arg.toString());
 }
@@ -50,3 +50,48 @@ export function stableStringify(obj) {
   };
   return inner(obj);
 }
+export function safeParseJSONDeep(input, childKeys = ["children"], keysToParse) {
+  const shouldParseKey = !keysToParse || keysToParse.length === 0 ? () => true : (k) => keysToParse.includes(k);
+  const looksLikeJSON = (s) => {
+    const t = s.trim();
+    if (t.length === 0) return false;
+    const c = t[0];
+    return c === "{" || c === "[" || c === '"' || c === "-" || c >= "0" && c <= "9" || t.startsWith("true") || t.startsWith("false") || t.startsWith("null");
+  };
+  const tryParse = (s) => {
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s;
+    }
+  };
+  const walk = (node) => {
+    if (isString(node)) {
+      return looksLikeJSON(node) ? tryParse(node) : node;
+    }
+    if (isArray(node)) {
+      return node.map(walk);
+    }
+    if (isPlainObject(node)) {
+      const out = {};
+      forOwn(node, (val, key) => {
+        if (isString(val) && shouldParseKey(key)) {
+          const parsed = looksLikeJSON(val) ? tryParse(val) : val;
+          out[key] = walk(parsed);
+        } else if (isArray(val) || isPlainObject(val)) {
+          out[key] = walk(val);
+        } else {
+          out[key] = val;
+        }
+      });
+      childKeys.forEach((ck) => {
+        if (isArray(out[ck])) {
+          out[ck] = out[ck].map(walk);
+        }
+      });
+      return out;
+    }
+    return node;
+  };
+  return walk(cloneDeep(input));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramathibodi/nuxt-commons",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",
@@ -92,6 +92,7 @@
     "uid": "^2.0.2",
     "vue": "^3.5.13",
     "vue-codemirror": "^6.1.1",
+    "vue-json-pretty": "^2.5.0",
     "vue-signature-pad": "^3.0.2",
     "vuetify": "^3.8.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"