@finema/core 1.4.220 → 2.1.0

package/dist/runtime/utils/FileHelper.spec.mjs

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { FileHelper } from "./FileHelper.mjs";
-describe("FileHelper", () => {
-  describe("dataURLtoFile", () => {
-    it("should convert a data URL to a File", async () => {
-      const dataUrl = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==";
-      const filename = "test.png";
-      const file = await FileHelper.dataURLtoFile(dataUrl, filename);
-      expect(file).toBeInstanceOf(File);
-      expect(file.name).toBe(filename);
-      expect(file.type).toBe("image/png");
-    });
-  });
-});

package/dist/runtime/utils/ObjectHelper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/utils/ObjectHelper.spec.mjs

@@ -1,52 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ObjectHelper } from "./ObjectHelper.mjs";
-describe("ObjectHelper", () => {
-  describe("createOption", () => {
-    it("should create an option object with the provided value and label", () => {
-      const value = "value1";
-      const label = "Label 1";
-      const option = ObjectHelper.createOption(value, label);
-      expect(option).toEqual({ value, label });
-    });
-    it("should create an option object with an empty label if not provided", () => {
-      const value = "value1";
-      const option = ObjectHelper.createOption(value);
-      expect(option).toEqual({ value, label: "" });
-    });
-  });
-  describe("toOption", () => {
-    it("should create an option object from the provided data", () => {
-      const data = { id: 1, name: "Option 1" };
-      const option = ObjectHelper.toOption(data);
-      expect(option).toEqual({ value: 1, label: "Option 1" });
-    });
-    it("should use the provided value and label attributes", () => {
-      const data = { code: "CODE1", description: "Description 1" };
-      const option = ObjectHelper.toOption(data, "code", "description");
-      expect(option).toEqual({ value: "CODE1", label: "Description 1" });
-    });
-  });
-  describe("toErrorStatus", () => {
-    it("should create an error status object from the provided error", () => {
-      const error = {
-        response: {
-          status: 400,
-          request: {
-            response: JSON.stringify({ code: "INVALID_REQUEST", message: "Invalid request" })
-          }
-        }
-      };
-      const status = ObjectHelper.toErrorStatus({}, error);
-      expect(status.isError).toBe(true);
-      expect(status.isSuccess).toBe(false);
-      expect(status.errorData).toEqual({ code: "INVALID_REQUEST", message: "Invalid request" });
-    });
-    it("should create a network error status if the error response status is missing", () => {
-      const error = {};
-      const status = ObjectHelper.toErrorStatus({}, error);
-      expect(status.isError).toBe(true);
-      expect(status.isSuccess).toBe(false);
-      expect(status.errorData).toEqual({ code: "NETWORK_ERROR", message: "Network error" });
-    });
-  });
-});

package/dist/runtime/utils/ParamHelper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/utils/ParamHelper.spec.mjs

@@ -1,78 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ParamHelper } from "./ParamHelper.mjs";
-describe("ParamHelper", () => {
-  describe("getParams", () => {
-    it("should merge params from opts and reqOptions", () => {
-      const opts = { params: { page: 1, limit: 10 } };
-      const reqOptions = { params: { sort: "name" } };
-      const result = ParamHelper.getParams(opts, reqOptions);
-      expect(result).toEqual({ page: 1, limit: 10, sort: "name" });
-    });
-    it("should return reqOptions.params if opts.params is not provided", () => {
-      const opts = {};
-      const reqOptions = { params: { sort: "name" } };
-      const result = ParamHelper.getParams(opts, reqOptions);
-      expect(result).toEqual({ sort: "name" });
-    });
-  });
-  describe("getBoolTrue", () => {
-    it("should return true for truthy values", () => {
-      expect(ParamHelper.getBoolTrue(true)).toBe(true);
-      expect(ParamHelper.getBoolTrue(1)).toBe(true);
-      expect(ParamHelper.getBoolTrue("true")).toBe(true);
-    });
-    it("should return false for falsy values", () => {
-      expect(ParamHelper.getBoolTrue(false)).toBe(false);
-      expect(ParamHelper.getBoolTrue(0)).toBe(false);
-      expect(ParamHelper.getBoolTrue("false")).toBe(false);
-    });
-    it("should return true for null value", () => {
-      expect(ParamHelper.getBoolTrue(null)).toBe(true);
-    });
-  });
-  describe("getBoolFalse", () => {
-    it("should return false for falsy values", () => {
-      expect(ParamHelper.getBoolFalse(false)).toBe(false);
-      expect(ParamHelper.getBoolFalse(0)).toBe(false);
-      expect(ParamHelper.getBoolFalse("false")).toBe(false);
-    });
-    it("should return true for truthy values", () => {
-      expect(ParamHelper.getBoolFalse(true)).toBe(true);
-      expect(ParamHelper.getBoolFalse(1)).toBe(true);
-      expect(ParamHelper.getBoolFalse("true")).toBe(true);
-    });
-    it("should return false for null value", () => {
-      expect(ParamHelper.getBoolFalse(null)).toBe(false);
-    });
-  });
-  describe("isNotFoundError", () => {
-    it('should return true if the error code is "NOT_FOUND"', () => {
-      const error = { code: "NOT_FOUND" };
-      expect(ParamHelper.isNotFoundError(error)).toBe(true);
-    });
-    it('should return false if the error code is not "NOT_FOUND"', () => {
-      const error = { code: "INTERNAL_SERVER_ERROR" };
-      expect(ParamHelper.isNotFoundError(error)).toBe(false);
-    });
-  });
-  describe("isChangeWithFalse", () => {
-    it("should return true if the value changes from true to false", () => {
-      expect(ParamHelper.isChangeWithFalse(false, true)).toBe(true);
-    });
-    it("should return false if the value does not change or changes to true", () => {
-      expect(ParamHelper.isChangeWithFalse(true, true)).toBe(false);
-      expect(ParamHelper.isChangeWithFalse(false, false)).toBe(false);
-      expect(ParamHelper.isChangeWithFalse(true, false)).toBe(false);
-    });
-  });
-  describe("isChangeWithTrue", () => {
-    it("should return true if the value changes from false to true", () => {
-      expect(ParamHelper.isChangeWithTrue(true, false)).toBe(true);
-    });
-    it("should return false if the value does not change or changes to false", () => {
-      expect(ParamHelper.isChangeWithTrue(false, false)).toBe(false);
-      expect(ParamHelper.isChangeWithTrue(true, true)).toBe(false);
-      expect(ParamHelper.isChangeWithTrue(false, true)).toBe(false);
-    });
-  });
-});

package/dist/runtime/utils/StringHelper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/utils/StringHelper.spec.mjs

@@ -1,76 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { StringHelper } from "./StringHelper.mjs";
-describe("StringHelper", () => {
-  describe("genString", () => {
-    it("should generate a random string of the specified length", () => {
-      const length = 10;
-      const result = StringHelper.genString(length);
-      expect(result).toHaveLength(length);
-      expect(typeof result).toBe("string");
-    });
-    it("should generate a random string of default length if not specified", () => {
-      const result = StringHelper.genString();
-      expect(result).toHaveLength(5);
-      expect(typeof result).toBe("string");
-    });
-  });
-  describe("withComma", () => {
-    it("should format a number with comma separator", () => {
-      expect(StringHelper.withComma(1e3)).toBe("1,000");
-      expect(StringHelper.withComma(1234.56)).toBe("1,234.56");
-    });
-    it('should return "0" for null or undefined values', () => {
-      expect(StringHelper.withComma(void 0)).toBe("0");
-    });
-  });
-  describe("withFixed", () => {
-    it("should format a number with comma separator and fixed decimal places", () => {
-      expect(StringHelper.withFixed(1e3)).toBe("1,000");
-      expect(StringHelper.withFixed(1234.56)).toBe("1,234.56");
-    });
-    it('should return "0" for null or undefined values', () => {
-      expect(StringHelper.withFixed(void 0)).toBe("0");
-    });
-  });
-  describe("split", () => {
-    it("should split a string into an array based on the specified separator", () => {
-      const str = "apple,banana,orange";
-      const separator = ",";
-      const result = StringHelper.split(str, separator);
-      expect(result).toEqual(["apple", "banana", "orange"]);
-    });
-    it("should return an empty array for null or undefined string", () => {
-      expect(StringHelper.split(null, ",")).toEqual([]);
-      expect(StringHelper.split(void 0, ",")).toEqual([]);
-    });
-  });
-  describe("joinURL", () => {
-    it("should join the provided URL parts", () => {
-      const result = StringHelper.joinURL("https://example.com", "path", "to", "resource");
-      expect(result).toBe("https://example.com/path/to/resource");
-    });
-  });
-  describe("truncate", () => {
-    it("should truncate a string if it exceeds the specified length", () => {
-      const str = "This is a long string that needs to be truncated";
-      const result = StringHelper.truncate(str, 20);
-      expect(result).toBe("This is a long strin...");
-    });
-    it("should return the original string if it does not exceed the specified length", () => {
-      const str = "Short string";
-      const result = StringHelper.truncate(str, 20);
-      expect(result).toBe("Short string");
-    });
-  });
-  describe("getError", () => {
-    it("should return the error message from the errorData", () => {
-      const errorData = { code: "ERROR_CODE", message: "Error message" };
-      const result = StringHelper.getError(errorData);
-      expect(result).toBe("Error message");
-    });
-    it("should return the default error message if the errorData is empty", () => {
-      const result = StringHelper.getError({}, "Default error message");
-      expect(result).toBe("Default error message");
-    });
-  });
-});

package/dist/runtime/utils/TimeHelper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/utils/TimeHelper.spec.mjs

@@ -1,79 +0,0 @@
-import { assert, describe, it, vi } from "vitest";
-import { TimeHelper } from "./TimeHelper.mjs";
-vi.mock("#core/composables/useConfig", () => ({
-  useCoreConfig: () => ({
-    date_format: "yyyy-MM-dd",
-    date_time_format: "yyyy-MM-dd HH:mm",
-    date_format_system: "yyyy-MM-dd",
-    date_time_format_system: "yyyy-MM-dd HH:mm",
-    time_format: "HH:mm",
-    is_thai_year: false,
-    time_zone: "Asia/Bangkok"
-  })
-}));
-describe("TimeHelper", async () => {
-  it("toUTC should convert time to UTC format", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutput = "2023-12-19 05:00";
-    const result = TimeHelper.toUTC(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("toUTC should convert time to UTC format 2", () => {
-    const inputTime = "2023-01-16T22:01:00Z";
-    const expectedOutput = "2023-01-16 22:01";
-    const result = TimeHelper.toUTC(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("toLocal should convert time to local format", () => {
-    const inputTime = "2023-01-16T22:00:00Z";
-    const expectedOutput = "2023-01-17 05:00";
-    const result = TimeHelper.toLocal(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("[thai year ]toLocal should convert time to local format", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutput = "2023-12-19 12:00";
-    const result = TimeHelper.toLocal(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("getCurrentDate should return the current date in yyyy-MM-dd format", () => {
-    const expectedOutputRegex = /^\d{4}-\d{2}-\d{2}$/;
-    const result = TimeHelper.getCurrentDate();
-    assert.match(result, expectedOutputRegex);
-  });
-  it("getDateFormTime should convert time to date format", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutput = "2023-12-19";
-    const result = TimeHelper.getDateFormTime(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("getDateFormTimeWithLocal should convert time to date format with local time", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutputRegex = /^\d{4}-\d{2}-\d{2}$/;
-    const result = TimeHelper.getDateFormTimeWithLocal(inputTime);
-    assert.match(result, expectedOutputRegex);
-  });
-  it("getISODateTimeFormTime should convert time to ISO date-time format", () => {
-    const inputTime = "2023-12-19 14:30";
-    const expectedOutput = "2023-12-19T14:30:00+07:00";
-    const result = TimeHelper.getISODateTimeFormTime(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("getDateTimeFormTime should convert time to date-time format", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutputRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
-    const result = TimeHelper.getDateTimeFormTime(inputTime);
-    assert.match(result, expectedOutputRegex);
-  });
-  it("getTimeFormTime should convert time to time format", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutputRegex = /^\d{2}:\d{2}$/;
-    const result = TimeHelper.getTimeFormTime(inputTime);
-    assert.match(result, expectedOutputRegex);
-  });
-  it("getCurrentDateTime should return the current date and time in yyyy-MM-dd HH:mm format", () => {
-    const expectedOutputRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
-    const result = TimeHelper.getCurrentDateTime();
-    assert.match(result, expectedOutputRegex);
-  });
-});

package/dist/runtime/utils/TimeHelper.thai.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/runtime/utils/TimeHelper.thai.spec.mjs

@@ -1,31 +0,0 @@
-import { assert, describe, it, vi } from "vitest";
-import { TimeHelper } from "./TimeHelper.mjs";
-vi.mock("#core/composables/useConfig", () => ({
-  useCoreConfig: () => ({
-    date_format: "yyyy-MM-dd",
-    date_time_format: "yyyy-MM-dd HH:mm",
-    time_format: "HH:mm",
-    is_thai_year: true,
-    time_zone: "Asia/Bangkok"
-  })
-}));
-describe("TimeHelper", async () => {
-  it("displayDate", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutput = "2566-12-19";
-    const result = TimeHelper.displayDate(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("displayDateTime", () => {
-    const inputTime = "2023-12-19 12:00";
-    const expectedOutput = "2566-12-19 12:00";
-    const result = TimeHelper.displayDateTime(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-  it("displayDateTime - iso", () => {
-    const inputTime = "2023-01-16T22:00:00Z";
-    const expectedOutput = "2566-01-17 05:00";
-    const result = TimeHelper.displayDateTime(inputTime);
-    assert.equal(result, expectedOutput);
-  });
-});

package/dist/types.d.ts

@@ -1,16 +0,0 @@
-
-import type { ModuleOptions } from './module'
-
-
-declare module '@nuxt/schema' {
-  interface NuxtConfig { ['core']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['core']?: ModuleOptions }
-}
-
-declare module 'nuxt/schema' {
-  interface NuxtConfig { ['core']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['core']?: ModuleOptions }
-}
-
-
-export type { core } from './module'

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

@@ -1,7 +1,7 @@
 import { addYears, format, formatISO, isDate, isValid, parse } from "date-fns";
 import * as locales from "date-fns/locale";
-import { useCoreConfig } from "#core/composables/useConfig";
 import { formatInTimeZone } from "date-fns-tz";
+import { useCoreConfig } from "#core/composables/useConfig";
 const dateFormat = useCoreConfig().date_format_system;
 const dateFormatDisplay = useCoreConfig().date_format;
 const dateTimeFormat = useCoreConfig().date_time_format_system;