@aerokit/sdk 12.44.0

package/dist/cjs/template/engines.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var engines_exports = {};
+__export(engines_exports, {
+  TemplateEngines: () => TemplateEngines
+});
+module.exports = __toCommonJS(engines_exports);
+var import_repository = require("@aerokit/sdk/platform/repository");
+const REGISTRY_PUBLIC = "/registry/public/";
+const MUSTACHE_FILE_EXTENSION = ".mustache";
+const TemplateEnginesFacade = Java.type("org.eclipse.dirigible.components.api.templates.TemplateEnginesFacade");
+class TemplateEngine {
+  /**
+   * Creates an instance of TemplateEngine.
+   *
+   * @param engine The native template engine object from the Facade.
+   * @param type The type of the engine ('mustache', 'velocity', 'javascript').
+   */
+  constructor(engine, type) {
+    this.engine = engine;
+    this.sm = type === "mustache" ? "{{" : null;
+    this.em = type === "mustache" ? "}}" : null;
+  }
+  /**
+   * Generates the final output by executing the template with the provided parameters.
+   * Note: Parameters are internally serialized to JSON before being passed to the native engine.
+   *
+   * @param location A string identifying the template (used for error reporting/caching, often a file path).
+   * @param template The raw template string content to process.
+   * @param parameters An object containing the context data to be used in the template.
+   * @returns The processed output string.
+   */
+  generate(location, template, parameters) {
+    return this.engine.generate(location, template, JSON.stringify(parameters), this.sm, this.em);
+  }
+  /**
+   * Sets a custom start marker for the template engine. This is primarily useful for Mustache.
+   *
+   * @param sm The new start marker string.
+   */
+  setSm(sm) {
+    this.sm = sm;
+  }
+  /**
+   * Sets a custom end marker for the template engine. This is primarily useful for Mustache.
+   *
+   * @param em The new end marker string.
+   */
+  setEm(em) {
+    this.em = em;
+  }
+}
+class TemplateEngines {
+  /**
+   * Retrieves the default template engine, which is currently the Velocity engine.
+   *
+   * @returns The default template engine instance.
+   */
+  static getDefaultEngine() {
+    return this.getVelocityEngine();
+  }
+  /**
+   * Retrieves the Mustache template engine instance.
+   * Mustache is often used for logic-less templating and uses '{{' and '}}' as default markers.
+   *
+   * @returns The Mustache template engine instance.
+   */
+  static getMustacheEngine() {
+    const engine = TemplateEnginesFacade.getMustacheEngine();
+    return new TemplateEngine(engine, "mustache");
+  }
+  /**
+   * Retrieves the Velocity template engine instance.
+   * Velocity is often used for complex templating with directives (e.g., #set, #foreach).
+   *
+   * @returns The Velocity template engine instance.
+   */
+  static getVelocityEngine() {
+    const engine = TemplateEnginesFacade.getVelocityEngine();
+    return new TemplateEngine(engine, "velocity");
+  }
+  /**
+   * Retrieves the JavaScript template engine instance (usually used for server-side evaluation).
+   *
+   * @returns The JavaScript template engine instance.
+   */
+  static getJavascriptEngine() {
+    const engine = TemplateEnginesFacade.getJavascriptEngine();
+    return new TemplateEngine(engine, "javascript");
+  }
+  /**
+   * Generates output by processing a raw template string using the **default template engine (Velocity)**.
+   *
+   * @param location A string identifying the template (used for error reporting/caching, often a file path).
+   * @param template The raw template string content to process.
+   * @param parameters An object containing key-value pairs to be used as context variables in the template.
+   * @returns The processed output string.
+   */
+  static generate(location, template, parameters) {
+    return this.getDefaultEngine().generate(location, template, parameters);
+  }
+  /**
+   * Loads a template from the public registry, selects an appropriate engine, and generates output.
+   * It uses the **Mustache engine** if the file extension is `.mustache`, otherwise it uses the **default (Velocity)**.
+   *
+   * @param location The path to the template file within the `/registry/public/` directory (e.g., 'templates/email.mustache').
+   * @param parameters An object containing key-value pairs to be used as context variables in the template.
+   * @returns The processed output string, or `undefined` if the resource does not exist.
+   */
+  static generateFromFile(location, parameters) {
+    const resource = import_repository.Repository.getResource(REGISTRY_PUBLIC + location);
+    if (resource.exists()) {
+      const isMustacheTemplate = location.endsWith(MUSTACHE_FILE_EXTENSION);
+      const engine = isMustacheTemplate ? this.getMustacheEngine() : this.getDefaultEngine();
+      const template = resource.getText();
+      return engine.generate(location, template, parameters);
+    }
+    return void 0;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = TemplateEngines;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/template/engines.ts"],
  "sourcesContent": ["import { Repository } from \"@aerokit/sdk/platform/repository\";\n\nconst REGISTRY_PUBLIC = \"/registry/public/\";\nconst MUSTACHE_FILE_EXTENSION = \".mustache\";\n\nconst TemplateEnginesFacade = Java.type(\"org.eclipse.dirigible.components.api.templates.TemplateEnginesFacade\");\n\n/**\n * An internal wrapper class that adapts a native template engine implementation.\n * It manages the engine instance and optional custom start/end markers.\n */\nclass TemplateEngine {\n\n    private engine: any;\n    /** The start marker string (e.g., '{{' for Mustache). */\n    private sm: string | null;\n    /** The end marker string (e.g., '}}' for Mustache). */\n    private em: string | null;\n\n    /**\n     * Creates an instance of TemplateEngine.\n     *\n     * @param engine The native template engine object from the Facade.\n     * @param type The type of the engine ('mustache', 'velocity', 'javascript').\n     */\n    constructor(engine: any, type: string) {\n        this.engine = engine;\n        // Default markers for Mustache engine\n        this.sm = type === \"mustache\" ? \"{{\" : null;\n        this.em = type === \"mustache\" ? \"}}\" : null;\n    }\n\n    /**\n     * Generates the final output by executing the template with the provided parameters.\n     * Note: Parameters are internally serialized to JSON before being passed to the native engine.\n     *\n     * @param location A string identifying the template (used for error reporting/caching, often a file path).\n     * @param template The raw template string content to process.\n     * @param parameters An object containing the context data to be used in the template.\n     * @returns The processed output string.\n     */\n    public generate(location: string, template: string, parameters: { [key: string]: any }): string {\n        return this.engine.generate(location, template, JSON.stringify(parameters), this.sm, this.em);\n    }\n\n    /**\n     * Sets a custom start marker for the template engine. This is primarily useful for Mustache.\n     *\n     * @param sm The new start marker string.\n     */\n    public setSm(sm: any) {\n        this.sm = sm;\n    }\n\n    /**\n     * Sets a custom end marker for the template engine. This is primarily useful for Mustache.\n     *\n     * @param em The new end marker string.\n     */\n    public setEm(em: any) {\n        this.em = em;\n    }\n}\n\n/**\n * Provides access to various server-side template engines (Velocity, Mustache, JavaScript).\n * It offers utility methods for generating content from templates directly or from files\n * stored in the registry.\n */\nexport class TemplateEngines {\n\n    /**\n     * Retrieves the default template engine, which is currently the Velocity engine.\n     *\n     * @returns The default template engine instance.\n     */\n    public static getDefaultEngine(): TemplateEngine {\n        return this.getVelocityEngine();\n    }\n\n    /**\n     * Retrieves the Mustache template engine instance.\n     * Mustache is often used for logic-less templating and uses '{{' and '}}' as default markers.\n     *\n     * @returns The Mustache template engine instance.\n     */\n    public static getMustacheEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getMustacheEngine();\n        return new TemplateEngine(engine, \"mustache\");\n    }\n\n    /**\n     * Retrieves the Velocity template engine instance.\n     * Velocity is often used for complex templating with directives (e.g., #set, #foreach).\n     *\n     * @returns The Velocity template engine instance.\n     */\n    public static getVelocityEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getVelocityEngine();\n        return new TemplateEngine(engine, \"velocity\");\n    }\n\n    /**\n     * Retrieves the JavaScript template engine instance (usually used for server-side evaluation).\n     *\n     * @returns The JavaScript template engine instance.\n     */\n    public static getJavascriptEngine(): TemplateEngine {\n        const engine = TemplateEnginesFacade.getJavascriptEngine();\n        return new TemplateEngine(engine, \"javascript\");\n    }\n\n    /**\n     * Generates output by processing a raw template string using the **default template engine (Velocity)**.\n     *\n     * @param location A string identifying the template (used for error reporting/caching, often a file path).\n     * @param template The raw template string content to process.\n     * @param parameters An object containing key-value pairs to be used as context variables in the template.\n     * @returns The processed output string.\n     */\n    public static generate(location: string, template: string, parameters: { [key: string]: any }): string {\n        return this.getDefaultEngine().generate(location, template, parameters);\n    }\n\n    /**\n     * Loads a template from the public registry, selects an appropriate engine, and generates output.\n     * It uses the **Mustache engine** if the file extension is `.mustache`, otherwise it uses the **default (Velocity)**.\n     *\n     * @param location The path to the template file within the `/registry/public/` directory (e.g., 'templates/email.mustache').\n     * @param parameters An object containing key-value pairs to be used as context variables in the template.\n     * @returns The processed output string, or `undefined` if the resource does not exist.\n     */\n    public static generateFromFile(location: string, parameters: { [key: string]: any }): string | undefined {\n        const resource = Repository.getResource(REGISTRY_PUBLIC + location);\n        if (resource.exists()) {\n            const isMustacheTemplate = location.endsWith(MUSTACHE_FILE_EXTENSION);\n            const engine = isMustacheTemplate ? this.getMustacheEngine() : this.getDefaultEngine();\n            const template = resource.getText();\n            return engine.generate(location, template, parameters);\n        }\n        return undefined;\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = TemplateEngines;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA2B;AAE3B,MAAM,kBAAkB;AACxB,MAAM,0BAA0B;AAEhC,MAAM,wBAAwB,KAAK,KAAK,sEAAsE;AAM9G,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcjB,YAAY,QAAa,MAAc;AACnC,SAAK,SAAS;AAEd,SAAK,KAAK,SAAS,aAAa,OAAO;AACvC,SAAK,KAAK,SAAS,aAAa,OAAO;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,SAAS,UAAkB,UAAkB,YAA4C;AAC5F,WAAO,KAAK,OAAO,SAAS,UAAU,UAAU,KAAK,UAAU,UAAU,GAAG,KAAK,IAAI,KAAK,EAAE;AAAA,EAChG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,MAAM,IAAS;AAClB,SAAK,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,MAAM,IAAS;AAClB,SAAK,KAAK;AAAA,EACd;AACJ;AAOO,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB,OAAc,mBAAmC;AAC7C,WAAO,KAAK,kBAAkB;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,oBAAoC;AAC9C,UAAM,SAAS,sBAAsB,kBAAkB;AACvD,WAAO,IAAI,eAAe,QAAQ,UAAU;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,oBAAoC;AAC9C,UAAM,SAAS,sBAAsB,kBAAkB;AACvD,WAAO,IAAI,eAAe,QAAQ,UAAU;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,sBAAsC;AAChD,UAAM,SAAS,sBAAsB,oBAAoB;AACzD,WAAO,IAAI,eAAe,QAAQ,YAAY;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,SAAS,UAAkB,UAAkB,YAA4C;AACnG,WAAO,KAAK,iBAAiB,EAAE,SAAS,UAAU,UAAU,UAAU;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,iBAAiB,UAAkB,YAAwD;AACrG,UAAM,WAAW,6BAAW,YAAY,kBAAkB,QAAQ;AAClE,QAAI,SAAS,OAAO,GAAG;AACnB,YAAM,qBAAqB,SAAS,SAAS,uBAAuB;AACpE,YAAM,SAAS,qBAAqB,KAAK,kBAAkB,IAAI,KAAK,iBAAiB;AACrF,YAAM,WAAW,SAAS,QAAQ;AAClC,aAAO,OAAO,SAAS,UAAU,UAAU,UAAU;AAAA,IACzD;AACA,WAAO;AAAA,EACX;AACJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/cjs/template/index.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var template_exports = {};
+__export(template_exports, {
+  engines: () => import_engines.TemplateEngines
+});
+module.exports = __toCommonJS(template_exports);
+var import_engines = require("./engines");
+__reExport(template_exports, require("./engines"), module.exports);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3RlbXBsYXRlL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBUZW1wbGF0ZUVuZ2luZXMgYXMgZW5naW5lcyB9IGZyb20gXCIuL2VuZ2luZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2VuZ2luZXNcIjsiXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEscUJBQTJDO0FBQzNDLDZCQUFjLHNCQURkOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/cjs/utils/alphanumeric.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var alphanumeric_exports = {};
+__export(alphanumeric_exports, {
+  Alphanumeric: () => Alphanumeric
+});
+module.exports = __toCommonJS(alphanumeric_exports);
+let LOWERCASEASCII = "abcdefghijklmnopqrstuvwxyz";
+const UPPERCASEASCII = LOWERCASEASCII.toUpperCase();
+const NUMBERS = "1234567890";
+class Alphanumeric {
+  static toAlphanumeric(string) {
+    return string.replace(/[^A-Za-z0-9_]/g, "");
+  }
+  /**
+   * Generates a random alphanumeric sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   */
+  static randomString(length, charset) {
+    let text = "";
+    if (length < 1)
+      length = 4;
+    for (var i = 0; i < length; i++)
+      text += charset.charAt(Math.floor(Math.random() * charset.length));
+    return text;
+  }
+  /**
+   * Generates a random alphanumeric sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   * @param lowercase {Boolean} Defaults to true
+   */
+  static alphanumeric(length, lowercase) {
+    let charset = LOWERCASEASCII + NUMBERS;
+    if (!lowercase) {
+      charset += UPPERCASEASCII;
+    }
+    return Alphanumeric.randomString(length, charset);
+  }
+  /**
+   * Generates a random ASCII sequence with the specified length
+   * @param length {Integer} Defaults to 4
+   * @param lowercase {Boolean} Defaults to true
+   */
+  static alpha(length, lowercase) {
+    let charset = LOWERCASEASCII;
+    if (!lowercase) {
+      charset += UPPERCASEASCII;
+    }
+    return Alphanumeric.randomString(length, charset);
+  }
+  /**
+   * Generates a random numeric value
+   * @param length {Integer} Defaults to 4
+   */
+  static numeric(length) {
+    return Alphanumeric.randomString(length, NUMBERS);
+  }
+  /**
+   * Tests is the provided `str` argument is a valid numeric sequence.
+   * @param str {String} the string to test
+   */
+  static isNumeric(str) {
+    let code, i, len;
+    for (i = 0, len = str.length; i < len; i++) {
+      code = str.charCodeAt(i);
+      if (!(code > 47 && code < 58)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Tests is the provided `str` argument is a valid alphanumeric sequence.
+   * @param str {String} the string to test
+   */
+  static isAlphanumeric(str) {
+    let code, i, len;
+    for (i = 0, len = str.length; i < len; i++) {
+      code = str.charCodeAt(i);
+      if (!(code > 47 && code < 58) && // numeric (0-9)
+      !(code > 64 && code < 91) && // upper alpha (A-Z)
+      !(code > 96 && code < 123)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Alphanumeric;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/utils/base64.js

@@ -0,0 +1,104 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base64_exports = {};
+__export(base64_exports, {
+  Base64: () => Base64
+});
+module.exports = __toCommonJS(base64_exports);
+var import_streams = require("@aerokit/sdk/io/streams");
+var import_bytes = require("@aerokit/sdk/io/bytes");
+const Base64Facade = Java.type("org.eclipse.dirigible.components.api.utils.Base64Facade");
+class Base64 {
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * standard **Base64 encoded string representation**.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting Base64 encoded string.
+   */
+  static encode(input) {
+    return import_bytes.Bytes.byteArrayToText(Base64.encodeAsNativeBytes(input));
+  }
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * **JavaScript byte array (any[])** containing the Base64 encoded representation.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting byte array containing the Base64 encoded data.
+   */
+  static encodeAsBytes(input) {
+    return import_bytes.Bytes.toJavaScriptBytes(Base64.encodeAsNativeBytes(input));
+  }
+  /**
+   * Base64 encoding: Converts the input data (text or byte array) into a
+   * **native Java byte array** containing the Base64 encoded representation.
+   * This method is generally for internal use.
+   *
+   * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+   * @returns The resulting native Java byte array containing the Base64 data.
+   */
+  static encodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = import_streams.Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = import_bytes.Bytes.toJavaBytes(data);
+    }
+    return Base64Facade.encodeNative(native);
+  }
+  /**
+   * Base64 decoding: Converts a Base64 input (text or byte array) back into
+   * the original **raw byte array (JavaScript any[])**.
+   *
+   * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded raw byte array (any[]). Returns null if decoding fails or input is null.
+   */
+  static decode(input) {
+    const output = Base64.decodeAsNativeBytes(input);
+    if (output) {
+      return import_bytes.Bytes.toJavaScriptBytes(output);
+    }
+    return output;
+  }
+  /**
+   * Base64 decoding: Converts a Base64 input (text or byte array) back into
+   * the original **native Java raw byte array**. This method is generally for internal use.
+   *
+   * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+   * @returns The decoded native Java byte array.
+   */
+  static decodeAsNativeBytes(input) {
+    const data = input;
+    let native;
+    if (typeof data === "string") {
+      const baos = import_streams.Streams.createByteArrayOutputStream();
+      baos.writeText(data);
+      native = baos.getBytesNative();
+    } else if (Array.isArray(data)) {
+      native = import_bytes.Bytes.toJavaBytes(data);
+    }
+    return Base64Facade.decodeNative(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Base64;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/utils/converter.js

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var converter_exports = {};
+__export(converter_exports, {
+  Converter: () => Converter
+});
+module.exports = __toCommonJS(converter_exports);
+class Converter {
+  /**
+   * Converts a date property value within an object into a Unix timestamp (milliseconds since epoch).
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the date property (e.g., 'dateCreated').
+   * @example
+   * // Before: { date: "2024-01-01T10:00:00Z" }
+   * Converter.setDate(obj, 'date');
+   * // After: { date: 1704096000000 }
+   */
+  static setDate(obj, property) {
+    if (obj && obj[property]) {
+      obj[property] = new Date(obj[property]).getTime();
+    }
+  }
+  /**
+   * Converts a date property value into an ISO 8601 string, adjusted to represent
+   * the start of that day (local midnight) to handle timezone offsets consistently.
+   * This is typically used for fields that should represent a date *only*, without time of day ambiguity.
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the date property (e.g., 'birthday').
+   * @example
+   * // If local timezone is EST (UTC-5):
+   * // Before: { date: "2024-01-01" }
+   * Converter.setLocalDate(obj, 'date');
+   * // After: { date: "2024-01-01T05:00:00.000Z" } (start of day UTC)
+   */
+  static setLocalDate(obj, property) {
+    if (obj && obj[property]) {
+      const date = new Date(obj[property]);
+      const offsetHours = -((/* @__PURE__ */ new Date()).getTimezoneOffset() / 60);
+      date.setHours(offsetHours, 0, 0, 0);
+      obj[property] = date.toISOString();
+    }
+  }
+  /**
+   * Explicitly coerces a property value to a strict boolean type (`true` or `false`).
+   * This handles truthy/falsy values like `1`, `0`, `null`, and empty strings.
+   *
+   * @param obj The object containing the property to be converted.
+   * @param property The string name of the boolean property (e.g., 'isActive').
+   * @example
+   * // Before: { flag: 1, other: null }
+   * Converter.setBoolean(obj, 'flag');
+   * Converter.setBoolean(obj, 'other');
+   * // After: { flag: true, other: false }
+   */
+  static setBoolean(obj, property) {
+    if (obj && obj[property] !== void 0) {
+      obj[property] = obj[property] ? true : false;
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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