lowcoder-map-component 0.1.1

package/src/utils/chartStyle.util.ts

@@ -0,0 +1,121 @@
+type StyleValue = string | undefined;
+
+// ReplacePrefixes dạng { old: new }
+type ReplacePrefixes = Record<string, string>;
+
+// ----------- TYPE LEVEL -----------
+type RemovePrefix<
+  K extends string,
+  Prefix extends string,
+> = K extends `${Prefix}${infer Rest}` ? Uncapitalize<Rest> : K;
+
+type ReplacePrefix<
+  K extends string,
+  P extends string,
+  R extends string,
+> = K extends `${P}${infer Rest}` ? `${R}${Capitalize<Rest>}` : K;
+
+type FormattedStyle<
+  T extends Record<string, StyleValue>,
+  Remove extends string = "chart",
+  Replace extends ReplacePrefixes = { text: "font" },
+> = {
+  [K in keyof T as K extends string
+    ? {
+        [P in keyof Replace & string]: ReplacePrefix<K, P, Replace[P]>;
+      }[keyof Replace & string] extends infer R
+      ? R extends string
+        ? R
+        : RemovePrefix<K, Remove>
+      : never
+    : never]: string;
+};
+
+// ----------- RUNTIME LEVEL -----------
+export function formatStyle<
+  T extends Record<string, StyleValue>,
+  Remove extends string = "chart",
+  Replace extends ReplacePrefixes = { text: "font" },
+>(
+  data: T,
+  removePrefixes: Remove[] = ["chart"] as Remove[],
+  replacePrefixes: Replace = { text: "font" } as unknown as Replace
+): FormattedStyle<T, Remove, Replace> {
+  const formatted: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    let newKey = key;
+
+    for (const prefix of removePrefixes) {
+      if (newKey.startsWith(prefix)) {
+        newKey =
+          newKey.charAt(prefix.length).toLowerCase() +
+          newKey.slice(prefix.length + 1);
+        break;
+      }
+    }
+
+    for (const [prefix, replacement] of Object.entries(replacePrefixes)) {
+      if (newKey.startsWith(prefix)) {
+        newKey =
+          replacement +
+          newKey.charAt(prefix.length).toUpperCase() +
+          newKey.slice(prefix.length + 1);
+        break;
+      }
+    }
+    if (newKey === "fontColor") formatted["color"] = value ?? "black";
+    else formatted[newKey] = value ?? "";
+  }
+
+  return formatted as FormattedStyle<T, Remove, Replace>;
+}
+
+export function formatAllStyles<
+  T extends Record<string, any>,
+  Remove extends string = "chart",
+  Replace extends ReplacePrefixes = { text: "font" },
+>(
+  obj: T,
+  removePrefixes: Remove[] = ["chart"] as Remove[],
+  replacePrefixes: Replace = { text: "font" } as unknown as Replace
+): {
+  [K in keyof T]: K extends `${string}Style`
+    ? T[K] extends Record<string, StyleValue>
+      ? FormattedStyle<T[K], Remove, Replace>
+      : T[K]
+    : T[K] extends Record<string, any>
+      ? ReturnType<typeof formatAllStyles<T[K], Remove, Replace>>
+      : T[K];
+} {
+  const result: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (
+      key.endsWith("Style") &&
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value)
+    ) {
+      result[key] = formatStyle(
+        value as Record<string, StyleValue>,
+        removePrefixes,
+        replacePrefixes
+      );
+    } else if (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value)
+    ) {
+      result[key] = formatAllStyles(
+        value as Record<string, any>,
+        removePrefixes,
+        replacePrefixes
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result as any;
+}

package/src/utils/columnExtractor.util.ts

@@ -0,0 +1,41 @@
+import { JSONObject } from "lowcoder-sdk";
+
+export interface ColumnDefinition {
+  align?: string;
+  dataIndex: string;
+  defaultSortOrder?: any;
+  fixed?: string | boolean;
+  key: string;
+  sortable?: boolean;
+  title: string;
+  visible: boolean;
+  width?: number;
+  render?: (value: any, record: any, index: number) => React.ReactNode;
+}
+
+export const extractColumnsFromData = (
+  data: JSONObject[]
+): ColumnDefinition[] => {
+  if (!data || data.length === 0) return [];
+
+  const sampleItem = data[0];
+  const keys = Object.keys(sampleItem).filter((key) => key !== "key");
+
+  return keys.map((key) => {
+    const sampleValue = sampleItem[key];
+    const isNumeric = typeof sampleValue === "number";
+    const isSparkline = key === "sparkline" && Array.isArray(sampleValue);
+
+    return {
+      title: key.charAt(0).toUpperCase() + key.slice(1),
+      dataIndex: key,
+      key: key,
+      visible: true,
+      sortable: false,
+      defaultSortOrder: "none",
+      align: isNumeric ? "right" : "left",
+      fixed: "none",
+      width: isSparkline ? 200 : isNumeric ? 120 : 150,
+    };
+  });
+};

package/src/utils/dataTransform.util.ts

@@ -0,0 +1,37 @@
+import Big from "big.js";
+import { isNumeric, JSONObject } from "lowcoder-sdk";
+
+export function transformData(
+  originData: JSONObject[],
+  xAxis: string,
+  seriesColumnNames: string[]
+) {
+  const dataMap = new Map<string, Record<string, any>>();
+  const initValue = Object.fromEntries(
+    seriesColumnNames.map((name) => [name, 0])
+  );
+
+  originData.forEach((item) => {
+    if (item === null || item === undefined) return;
+
+    const groupValue = item[xAxis] as string;
+    if (!dataMap.has(groupValue)) {
+      dataMap.set(groupValue, { ...initValue, [xAxis]: groupValue });
+    }
+
+    const groupData = dataMap.get(groupValue)!;
+    seriesColumnNames.forEach((key) => {
+      if (key === xAxis) return;
+
+      if (isNumeric(item[key])) {
+        groupData[key] = Big(item[key] as string)
+          .add(groupData[key])
+          .toNumber();
+      } else {
+        groupData[key] += 1;
+      }
+    });
+  });
+
+  return Array.from(dataMap.values());
+}

package/src/utils/deepEqual.util.ts

@@ -0,0 +1,29 @@
+export function deepEqual(a: any, b: any): boolean {
+  // Handle null and undefined cases
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+
+  // Handle arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  // Handle objects
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!b.hasOwnProperty(key) || !deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+
+  // Handle primitives
+  return a === b;
+}