@intlayer/chokidar 1.2.0

package/dist/cjs/transpiler/dictionary_to_type/index.d.ts

@@ -0,0 +1,3 @@
+export { createModuleAugmentation, getTypeName } from './createModuleAugmentation.js';
+export { createTypes, generateTypeScriptType, generateTypeScriptTypeContent } from './createType.js';
+import '@intlayer/core';

package/dist/cjs/transpiler/intlater_module_to_dictionary/extractNestedJSON.cjs

@@ -0,0 +1,45 @@
+"use strict";
+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 extractNestedJSON_exports = {};
+__export(extractNestedJSON_exports, {
+  extractObjectsWithId: () => extractObjectsWithId
+});
+module.exports = __toCommonJS(extractNestedJSON_exports);
+const extractObjectsWithId = (input) => {
+  const search = (obj, results2) => {
+    if (obj && typeof obj === "object") {
+      if (Object.prototype.hasOwnProperty.call(obj, "id")) {
+        results2.push(obj);
+      }
+      for (const key of Object.keys(obj)) {
+        if (typeof obj[key] === "object") {
+          search(obj[key], results2);
+        }
+      }
+    }
+  };
+  const results = [];
+  search(input, results);
+  return results;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractObjectsWithId
+});
+//# sourceMappingURL=extractNestedJSON.cjs.map

package/dist/cjs/transpiler/intlater_module_to_dictionary/extractNestedJSON.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/extractNestedJSON.ts"],"sourcesContent":["import type { Content, ContentModule } from '@intlayer/core';\n\n/**\n *\n * This function extracts all nested objects with an 'id' field from the input object and returns them as an array\n *\n * Example:\n *\n * const input = {\n *  id: '1',\n *  name: 'John Doe',\n *  address: {\n *    id: '2',\n *    street: '123 Main St',\n *    city: 'Springfield',\n *    state: 'IL'\n *  },\n * };\n * const result = extractObjectsWithId(input);\n * console.log(result);\n *\n * Output:\n *\n * [{\n *  id: '1',\n *  name: 'John Doe',\n *  address: {\n *    id: '2',\n *    street: '123 Main St',\n *    city: 'Springfield',\n *    state: 'IL'\n *  }\n * },\n * {\n *  id: '2',\n *  street: '123 Main St',\n *  city: 'Springfield',\n *  state: 'IL'\n * }]\n *\n */\nexport const extractObjectsWithId = (input: ContentModule): ContentModule[] => {\n  // Function to recursively search and extract nested objects with an 'id'\n  const search = (obj: Content, results: ContentModule[]): void => {\n    if (obj && typeof obj === 'object') {\n      if (Object.prototype.hasOwnProperty.call(obj, 'id')) {\n        results.push(obj as ContentModule);\n      }\n      for (const key of Object.keys(obj)) {\n        if (typeof obj[key] === 'object') {\n          search(obj[key] as Content, results);\n        }\n      }\n    }\n  };\n\n  const results: ContentModule[] = [];\n  search(input, results);\n  return results;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyCO,MAAM,uBAAuB,CAAC,UAA0C;AAE7E,QAAM,SAAS,CAAC,KAAcA,aAAmC;AAC/D,QAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,UAAI,OAAO,UAAU,eAAe,KAAK,KAAK,IAAI,GAAG;AACnD,QAAAA,SAAQ,KAAK,GAAoB;AAAA,MACnC;AACA,iBAAW,OAAO,OAAO,KAAK,GAAG,GAAG;AAClC,YAAI,OAAO,IAAI,GAAG,MAAM,UAAU;AAChC,iBAAO,IAAI,GAAG,GAAcA,QAAO;AAAA,QACrC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,UAA2B,CAAC;AAClC,SAAO,OAAO,OAAO;AACrB,SAAO;AACT;","names":["results"]}

package/dist/cjs/transpiler/intlater_module_to_dictionary/extractNestedJSON.d.ts

@@ -0,0 +1,44 @@
+import { ContentModule } from '@intlayer/core';
+
+/**
+ *
+ * This function extracts all nested objects with an 'id' field from the input object and returns them as an array
+ *
+ * Example:
+ *
+ * const input = {
+ *  id: '1',
+ *  name: 'John Doe',
+ *  address: {
+ *    id: '2',
+ *    street: '123 Main St',
+ *    city: 'Springfield',
+ *    state: 'IL'
+ *  },
+ * };
+ * const result = extractObjectsWithId(input);
+ * console.log(result);
+ *
+ * Output:
+ *
+ * [{
+ *  id: '1',
+ *  name: 'John Doe',
+ *  address: {
+ *    id: '2',
+ *    street: '123 Main St',
+ *    city: 'Springfield',
+ *    state: 'IL'
+ *  }
+ * },
+ * {
+ *  id: '2',
+ *  street: '123 Main St',
+ *  city: 'Springfield',
+ *  state: 'IL'
+ * }]
+ *
+ */
+declare const extractObjectsWithId: (input: ContentModule) => ContentModule[];
+
+export { extractObjectsWithId };

package/dist/cjs/transpiler/intlater_module_to_dictionary/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 intlater_module_to_dictionary_exports = {};
+module.exports = __toCommonJS(intlater_module_to_dictionary_exports);
+__reExport(intlater_module_to_dictionary_exports, require('./extractNestedJSON.cjs'), module.exports);
+__reExport(intlater_module_to_dictionary_exports, require('./processModule.cjs'), module.exports);
+__reExport(intlater_module_to_dictionary_exports, require('./transpileContentDeclaration.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./extractNestedJSON.cjs'),
+  ...require('./processModule.cjs'),
+  ...require('./transpileContentDeclaration.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/transpiler/intlater_module_to_dictionary/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/index.ts"],"sourcesContent":["export * from './extractNestedJSON';\nexport * from './processModule';\nexport * from './transpileContentDeclaration';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,kDAAc,gCAAd;AACA,kDAAc,4BADd;AAEA,kDAAc,0CAFd;","names":[]}

package/dist/cjs/transpiler/intlater_module_to_dictionary/index.d.ts

@@ -0,0 +1,4 @@
+export { extractObjectsWithId } from './extractNestedJSON.js';
+export { processContentDeclaration } from './processModule.js';
+export { transpileContentDeclaration } from './transpileContentDeclaration.js';
+import '@intlayer/core';

package/dist/cjs/transpiler/intlater_module_to_dictionary/loadContentDeclaration.cjs

@@ -0,0 +1,98 @@
+"use strict";
+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 loadContentDeclaration_exports = {};
+__export(loadContentDeclaration_exports, {
+  loadContentDeclaration: () => loadContentDeclaration
+});
+module.exports = __toCommonJS(loadContentDeclaration_exports);
+var import_module = require("module");
+var import_vm = require("vm");
+var import_esbuild = require("esbuild");
+const import_meta = {};
+const isESModule = typeof import_meta.url === "string";
+const sandboxContext = {
+  exports: {
+    default: {}
+  },
+  module: {
+    exports: {}
+  },
+  console,
+  require: isESModule ? (0, import_module.createRequire)(import_meta.url) : require
+};
+const transformationOption = {
+  loader: {
+    ".js": "js",
+    ".jsx": "jsx",
+    ".mjs": "js",
+    ".ts": "ts",
+    ".tsx": "tsx",
+    ".cjs": "js",
+    ".json": "json"
+  },
+  format: "cjs",
+  // Output format as commonjs
+  target: "es2017",
+  packages: "external",
+  write: false,
+  bundle: true
+};
+const filterValidContentDeclaration = (contentDeclaration) => {
+  return contentDeclaration;
+};
+const loadContentDeclaration = (contentDeclarationFilePath) => {
+  let contentDeclaration = void 0;
+  const fileExtension = contentDeclarationFilePath.split(".").pop() ?? "";
+  try {
+    if (fileExtension === "json") {
+      return require(contentDeclarationFilePath);
+    }
+    const moduleResult = (0, import_esbuild.buildSync)({
+      entryPoints: [contentDeclarationFilePath],
+      ...transformationOption
+    });
+    const moduleResultString = moduleResult.outputFiles?.[0].text;
+    if (!moduleResultString) {
+      console.error("Configuration file could not be loaded.");
+      return void 0;
+    }
+    (0, import_vm.runInNewContext)(moduleResultString, sandboxContext);
+    if (sandboxContext.exports.default && Object.keys(sandboxContext.exports.default).length > 0) {
+      contentDeclaration = sandboxContext.exports.default;
+    } else if (sandboxContext.module.exports.defaults && Object.keys(sandboxContext.module.exports.defaults).length > 0) {
+      contentDeclaration = sandboxContext.module.exports.default;
+    } else if (sandboxContext.module.exports.default && Object.keys(sandboxContext.module.exports.default).length > 0) {
+      contentDeclaration = sandboxContext.module.exports.default;
+    } else if (sandboxContext.module.exports && Object.keys(sandboxContext.module.exports).length > 0) {
+      contentDeclaration = sandboxContext.module.exports;
+    }
+    if (typeof contentDeclaration === "undefined") {
+      console.error("Configuration file could not be loaded.");
+      return void 0;
+    }
+    return filterValidContentDeclaration(contentDeclaration);
+  } catch (error) {
+    console.error("Error:", error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadContentDeclaration
+});
+//# sourceMappingURL=loadContentDeclaration.cjs.map

package/dist/cjs/transpiler/intlater_module_to_dictionary/loadContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/loadContentDeclaration.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nimport { createRequire } from 'module';\nimport { type Context, runInNewContext } from 'vm';\nimport type { ContentModule } from '@intlayer/core';\nimport { type BuildOptions, buildSync, type BuildResult } from 'esbuild';\n\nconst isESModule = typeof import.meta.url === 'string';\n\nconst sandboxContext: Context = {\n  exports: {\n    default: {},\n  },\n  module: {\n    exports: {},\n  },\n  console,\n  require: isESModule ? createRequire(import.meta.url) : require,\n};\n\nconst transformationOption: BuildOptions = {\n  loader: {\n    '.js': 'js',\n    '.jsx': 'jsx',\n    '.mjs': 'js',\n    '.ts': 'ts',\n    '.tsx': 'tsx',\n    '.cjs': 'js',\n    '.json': 'json',\n  },\n  format: 'cjs', // Output format as commonjs\n  target: 'es2017',\n  packages: 'external',\n  write: false,\n  bundle: true,\n};\n\nconst filterValidContentDeclaration = (\n  contentDeclaration: ContentModule\n): ContentModule => {\n  // @TODO Implement filtering of valid content declaration\n  return contentDeclaration;\n};\n\n/**\n * Load the content declaration from the given path\n *\n * Accepts JSON, JS, MJS and TS files as configuration\n */\nexport const loadContentDeclaration = (\n  contentDeclarationFilePath: string\n): ContentModule | undefined => {\n  let contentDeclaration: ContentModule | undefined = undefined;\n\n  const fileExtension = contentDeclarationFilePath.split('.').pop() ?? '';\n\n  try {\n    if (fileExtension === 'json') {\n      // Assume JSON\n      return require(contentDeclarationFilePath);\n    }\n\n    // Rest is JS, MJS or TS\n\n    const moduleResult: BuildResult = buildSync({\n      entryPoints: [contentDeclarationFilePath],\n\n      ...transformationOption,\n    });\n\n    const moduleResultString = moduleResult.outputFiles?.[0].text;\n\n    if (!moduleResultString) {\n      console.error('Configuration file could not be loaded.');\n      return undefined;\n    }\n\n    runInNewContext(moduleResultString, sandboxContext);\n\n    if (\n      sandboxContext.exports.default &&\n      Object.keys(sandboxContext.exports.default).length > 0\n    ) {\n      // ES Module\n      contentDeclaration = sandboxContext.exports.default;\n    } else if (\n      sandboxContext.module.exports.defaults &&\n      Object.keys(sandboxContext.module.exports.defaults).length > 0\n    ) {\n      // CommonJS\n      contentDeclaration = sandboxContext.module.exports.default;\n    } else if (\n      sandboxContext.module.exports.default &&\n      Object.keys(sandboxContext.module.exports.default).length > 0\n    ) {\n      // ES Module\n      contentDeclaration = sandboxContext.module.exports.default;\n    } else if (\n      sandboxContext.module.exports &&\n      Object.keys(sandboxContext.module.exports).length > 0\n    ) {\n      // Other\n      contentDeclaration = sandboxContext.module.exports;\n    }\n\n    if (typeof contentDeclaration === 'undefined') {\n      console.error('Configuration file could not be loaded.');\n      return undefined;\n    }\n\n    return filterValidContentDeclaration(contentDeclaration);\n  } catch (error) {\n    console.error('Error:', error);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAA8B;AAC9B,gBAA8C;AAE9C,qBAA+D;AAJ/D;AAMA,MAAM,aAAa,OAAO,YAAY,QAAQ;AAE9C,MAAM,iBAA0B;AAAA,EAC9B,SAAS;AAAA,IACP,SAAS,CAAC;AAAA,EACZ;AAAA,EACA,QAAQ;AAAA,IACN,SAAS,CAAC;AAAA,EACZ;AAAA,EACA;AAAA,EACA,SAAS,iBAAa,6BAAc,YAAY,GAAG,IAAI;AACzD;AAEA,MAAM,uBAAqC;AAAA,EACzC,QAAQ;AAAA,IACN,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,SAAS;AAAA,EACX;AAAA,EACA,QAAQ;AAAA;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,QAAQ;AACV;AAEA,MAAM,gCAAgC,CACpC,uBACkB;AAElB,SAAO;AACT;AAOO,MAAM,yBAAyB,CACpC,+BAC8B;AAC9B,MAAI,qBAAgD;AAEpD,QAAM,gBAAgB,2BAA2B,MAAM,GAAG,EAAE,IAAI,KAAK;AAErE,MAAI;AACF,QAAI,kBAAkB,QAAQ;AAE5B,aAAO,QAAQ,0BAA0B;AAAA,IAC3C;AAIA,UAAM,mBAA4B,0BAAU;AAAA,MAC1C,aAAa,CAAC,0BAA0B;AAAA,MAExC,GAAG;AAAA,IACL,CAAC;AAED,UAAM,qBAAqB,aAAa,cAAc,CAAC,EAAE;AAEzD,QAAI,CAAC,oBAAoB;AACvB,cAAQ,MAAM,yCAAyC;AACvD,aAAO;AAAA,IACT;AAEA,mCAAgB,oBAAoB,cAAc;AAElD,QACE,eAAe,QAAQ,WACvB,OAAO,KAAK,eAAe,QAAQ,OAAO,EAAE,SAAS,GACrD;AAEA,2BAAqB,eAAe,QAAQ;AAAA,IAC9C,WACE,eAAe,OAAO,QAAQ,YAC9B,OAAO,KAAK,eAAe,OAAO,QAAQ,QAAQ,EAAE,SAAS,GAC7D;AAEA,2BAAqB,eAAe,OAAO,QAAQ;AAAA,IACrD,WACE,eAAe,OAAO,QAAQ,WAC9B,OAAO,KAAK,eAAe,OAAO,QAAQ,OAAO,EAAE,SAAS,GAC5D;AAEA,2BAAqB,eAAe,OAAO,QAAQ;AAAA,IACrD,WACE,eAAe,OAAO,WACtB,OAAO,KAAK,eAAe,OAAO,OAAO,EAAE,SAAS,GACpD;AAEA,2BAAqB,eAAe,OAAO;AAAA,IAC7C;AAEA,QAAI,OAAO,uBAAuB,aAAa;AAC7C,cAAQ,MAAM,yCAAyC;AACvD,aAAO;AAAA,IACT;AAEA,WAAO,8BAA8B,kBAAkB;AAAA,EACzD,SAAS,OAAO;AACd,YAAQ,MAAM,UAAU,KAAK;AAAA,EAC/B;AACF;","names":[]}

package/dist/cjs/transpiler/intlater_module_to_dictionary/loadContentDeclaration.d.ts

@@ -0,0 +1,10 @@
+import { ContentModule } from '@intlayer/core';
+
+/**
+ * Load the content declaration from the given path
+ *
+ * Accepts JSON, JS, MJS and TS files as configuration
+ */
+declare const loadContentDeclaration: (contentDeclarationFilePath: string) => ContentModule | undefined;
+
+export { loadContentDeclaration };

package/dist/cjs/transpiler/intlater_module_to_dictionary/processModule.cjs

@@ -0,0 +1,69 @@
+"use strict";
+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 processModule_exports = {};
+__export(processModule_exports, {
+  processContentDeclaration: () => processContentDeclaration
+});
+module.exports = __toCommonJS(processModule_exports);
+var import_path = require("path");
+var import_loadContentDeclaration = require('./loadContentDeclaration.cjs');
+const processFunctionResults = async (entry) => {
+  if (entry && typeof entry === "object") {
+    const promises = [];
+    const result = {};
+    for (const key of Object.keys(entry)) {
+      const field = entry?.[key];
+      if (typeof field === "object") {
+        result[key] = await processFunctionResults(
+          field
+        );
+      }
+      if (typeof field === "function") {
+        const promise = (async () => {
+          const value = await field();
+          result[key] = value;
+        })();
+        promises.push(promise);
+      } else {
+        result[key] = field;
+      }
+    }
+    await Promise.all(promises);
+    return result;
+  }
+  return entry;
+};
+const processContentDeclaration = async (file) => {
+  try {
+    const functionPath = (0, import_path.resolve)(file);
+    const entry = (0, import_loadContentDeclaration.loadContentDeclaration)(functionPath);
+    if (!entry) {
+      console.error("No entry found in module:", functionPath);
+      return;
+    }
+    return await processFunctionResults(entry);
+  } catch (error) {
+    console.error("Error processing module:", error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processContentDeclaration
+});
+//# sourceMappingURL=processModule.cjs.map

package/dist/cjs/transpiler/intlater_module_to_dictionary/processModule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/processModule.ts"],"sourcesContent":["import { resolve } from 'path';\nimport type {\n  Content,\n  ContentModule,\n  FlatContent,\n  FlatContentValue,\n} from '@intlayer/core';\nimport { loadContentDeclaration } from './loadContentDeclaration';\n\n/**\n * Function to replace function and async function fields with their results in the object\n */\nconst processFunctionResults = async (entry: Content): Promise<FlatContent> => {\n  if (entry && typeof entry === 'object') {\n    const promises: Promise<void>[] = [];\n    const result: FlatContent = {};\n\n    for (const key of Object.keys(entry)) {\n      const field = entry?.[key];\n\n      if (typeof field === 'object') {\n        result[key] = (await processFunctionResults(\n          field as Content\n        )) as FlatContentValue;\n      }\n\n      if (typeof field === 'function') {\n        // Wait for the function to resolve if it's an async function\n        const promise = (async () => {\n          // Execute the function and await the result if it's a Promise\n          const value = await field();\n          result[key] = value as FlatContentValue;\n        })();\n        promises.push(promise);\n      } else {\n        result[key] = field as FlatContentValue;\n      }\n    }\n\n    // Wait for all async operations to complete\n    await Promise.all(promises);\n\n    return result;\n  }\n\n  return entry;\n};\n\n/**\n * Function to load, process the module and return the Intlayer ContentModule from the module file\n */\nexport const processContentDeclaration = async (file: string) => {\n  try {\n    const functionPath = resolve(file);\n    const entry = loadContentDeclaration(functionPath);\n\n    if (!entry) {\n      console.error('No entry found in module:', functionPath);\n      return;\n    }\n\n    return (await processFunctionResults(entry)) as ContentModule;\n  } catch (error) {\n    console.error('Error processing module:', error);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAwB;AAOxB,oCAAuC;AAKvC,MAAM,yBAAyB,OAAO,UAAyC;AAC7E,MAAI,SAAS,OAAO,UAAU,UAAU;AACtC,UAAM,WAA4B,CAAC;AACnC,UAAM,SAAsB,CAAC;AAE7B,eAAW,OAAO,OAAO,KAAK,KAAK,GAAG;AACpC,YAAM,QAAQ,QAAQ,GAAG;AAEzB,UAAI,OAAO,UAAU,UAAU;AAC7B,eAAO,GAAG,IAAK,MAAM;AAAA,UACnB;AAAA,QACF;AAAA,MACF;AAEA,UAAI,OAAO,UAAU,YAAY;AAE/B,cAAM,WAAW,YAAY;AAE3B,gBAAM,QAAQ,MAAM,MAAM;AAC1B,iBAAO,GAAG,IAAI;AAAA,QAChB,GAAG;AACH,iBAAS,KAAK,OAAO;AAAA,MACvB,OAAO;AACL,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AAGA,UAAM,QAAQ,IAAI,QAAQ;AAE1B,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAKO,MAAM,4BAA4B,OAAO,SAAiB;AAC/D,MAAI;AACF,UAAM,mBAAe,qBAAQ,IAAI;AACjC,UAAM,YAAQ,sDAAuB,YAAY;AAEjD,QAAI,CAAC,OAAO;AACV,cAAQ,MAAM,6BAA6B,YAAY;AACvD;AAAA,IACF;AAEA,WAAQ,MAAM,uBAAuB,KAAK;AAAA,EAC5C,SAAS,OAAO;AACd,YAAQ,MAAM,4BAA4B,KAAK;AAAA,EACjD;AACF;","names":[]}

package/dist/cjs/transpiler/intlater_module_to_dictionary/processModule.d.ts

@@ -0,0 +1,8 @@
+import { ContentModule } from '@intlayer/core';
+
+/**
+ * Function to load, process the module and return the Intlayer ContentModule from the module file
+ */
+declare const processContentDeclaration: (file: string) => Promise<ContentModule | undefined>;
+
+export { processContentDeclaration };

package/dist/cjs/transpiler/intlater_module_to_dictionary/transpileContentDeclaration.cjs

@@ -0,0 +1,66 @@
+"use strict";
+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 transpileContentDeclaration_exports = {};
+__export(transpileContentDeclaration_exports, {
+  transpileContentDeclaration: () => transpileContentDeclaration
+});
+module.exports = __toCommonJS(transpileContentDeclaration_exports);
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_extractNestedJSON = require('./extractNestedJSON.cjs');
+var import_processModule = require('./processModule.cjs');
+const { content } = (0, import_config.getConfiguration)();
+const { dictionariesDir } = content;
+const buildDictionary = async (dictionaries) => {
+  const resultDictionariesPaths = [];
+  for await (const content2 of dictionaries) {
+    const contentString = JSON.stringify(content2);
+    const id = content2.id;
+    const outputFileName = `${id}.json`;
+    const resultFilePath = (0, import_path.resolve)(dictionariesDir, outputFileName);
+    await (0, import_promises.writeFile)(resultFilePath, contentString, "utf8").catch((err) => {
+      console.error(`Error creating ${outputFileName}:`, err);
+    });
+    resultDictionariesPaths.push(resultFilePath);
+  }
+  return resultDictionariesPaths;
+};
+const transpileContentDeclaration = async (contentDeclarationsPaths) => {
+  const resultDictionariesPaths = [];
+  if (typeof contentDeclarationsPaths === "string") {
+    contentDeclarationsPaths = [contentDeclarationsPaths];
+  }
+  await (0, import_promises.mkdir)((0, import_path.resolve)(dictionariesDir), { recursive: true });
+  for await (const contentDeclarationPath of contentDeclarationsPaths) {
+    const result = await (0, import_processModule.processContentDeclaration)(contentDeclarationPath);
+    if (!result) {
+      continue;
+    }
+    const nestedContent = (0, import_extractNestedJSON.extractObjectsWithId)(result);
+    const dictionariesPaths = await buildDictionary(nestedContent);
+    resultDictionariesPaths.push(...dictionariesPaths);
+  }
+  return resultDictionariesPaths;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transpileContentDeclaration
+});
+//# sourceMappingURL=transpileContentDeclaration.cjs.map

package/dist/cjs/transpiler/intlater_module_to_dictionary/transpileContentDeclaration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/intlater_module_to_dictionary/transpileContentDeclaration.ts"],"sourcesContent":["import { mkdir, writeFile } from 'fs/promises';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport type { ContentModule } from '@intlayer/core';\nimport { extractObjectsWithId } from './extractNestedJSON';\nimport { processContentDeclaration } from './processModule';\n\nconst { content } = getConfiguration();\nconst { dictionariesDir } = content;\n\nconst buildDictionary = async (dictionaries: ContentModule[]) => {\n  const resultDictionariesPaths: string[] = [];\n\n  for await (const content of dictionaries) {\n    const contentString = JSON.stringify(content);\n\n    const id = content.id;\n    const outputFileName = `${id}.json`;\n    const resultFilePath = resolve(dictionariesDir, outputFileName);\n\n    // Create the json file\n    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {\n      console.error(`Error creating ${outputFileName}:`, err);\n    });\n\n    resultDictionariesPaths.push(resultFilePath);\n  }\n\n  return resultDictionariesPaths;\n};\n\n/**\n * This function transpile the bundled code to to make dictionaries as JSON files\n */\nexport const transpileContentDeclaration = async (\n  contentDeclarationsPaths: string[] | string\n) => {\n  const resultDictionariesPaths: string[] = [];\n\n  if (typeof contentDeclarationsPaths === 'string') {\n    contentDeclarationsPaths = [contentDeclarationsPaths];\n  }\n\n  // Create the dictionaries folder if it doesn't exist\n  await mkdir(resolve(dictionariesDir), { recursive: true });\n\n  for await (const contentDeclarationPath of contentDeclarationsPaths) {\n    const result = await processContentDeclaration(contentDeclarationPath);\n\n    if (!result) {\n      continue;\n    }\n\n    const nestedContent: ContentModule[] = extractObjectsWithId(result);\n\n    const dictionariesPaths: string[] = await buildDictionary(nestedContent);\n\n    resultDictionariesPaths.push(...dictionariesPaths);\n  }\n\n  return resultDictionariesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAiC;AACjC,kBAAwB;AACxB,oBAAiC;AAEjC,+BAAqC;AACrC,2BAA0C;AAE1C,MAAM,EAAE,QAAQ,QAAI,gCAAiB;AACrC,MAAM,EAAE,gBAAgB,IAAI;AAE5B,MAAM,kBAAkB,OAAO,iBAAkC;AAC/D,QAAM,0BAAoC,CAAC;AAE3C,mBAAiBA,YAAW,cAAc;AACxC,UAAM,gBAAgB,KAAK,UAAUA,QAAO;AAE5C,UAAM,KAAKA,SAAQ;AACnB,UAAM,iBAAiB,GAAG,EAAE;AAC5B,UAAM,qBAAiB,qBAAQ,iBAAiB,cAAc;AAG9D,cAAM,2BAAU,gBAAgB,eAAe,MAAM,EAAE,MAAM,CAAC,QAAQ;AACpE,cAAQ,MAAM,kBAAkB,cAAc,KAAK,GAAG;AAAA,IACxD,CAAC;AAED,4BAAwB,KAAK,cAAc;AAAA,EAC7C;AAEA,SAAO;AACT;AAKO,MAAM,8BAA8B,OACzC,6BACG;AACH,QAAM,0BAAoC,CAAC;AAE3C,MAAI,OAAO,6BAA6B,UAAU;AAChD,+BAA2B,CAAC,wBAAwB;AAAA,EACtD;AAGA,YAAM,2BAAM,qBAAQ,eAAe,GAAG,EAAE,WAAW,KAAK,CAAC;AAEzD,mBAAiB,0BAA0B,0BAA0B;AACnE,UAAM,SAAS,UAAM,gDAA0B,sBAAsB;AAErE,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AAEA,UAAM,oBAAiC,+CAAqB,MAAM;AAElE,UAAM,oBAA8B,MAAM,gBAAgB,aAAa;AAEvE,4BAAwB,KAAK,GAAG,iBAAiB;AAAA,EACnD;AAEA,SAAO;AACT;","names":["content"]}

package/dist/cjs/transpiler/intlater_module_to_dictionary/transpileContentDeclaration.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This function transpile the bundled code to to make dictionaries as JSON files
+ */
+declare const transpileContentDeclaration: (contentDeclarationsPaths: string[] | string) => Promise<string[]>;
+
+export { transpileContentDeclaration };

package/dist/cjs/utils.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getFileHash: () => getFileHash,
+  transformToCamelCase: () => transformToCamelCase
+});
+module.exports = __toCommonJS(utils_exports);
+var import_crypto_js = __toESM(require("crypto-js"));
+const getFileHash = (filePath) => {
+  const hash = import_crypto_js.default.SHA3(filePath);
+  return hash.toString(import_crypto_js.default.enc.Base64).replace(/[^A-Z\d]/gi, "").substring(0, 20);
+};
+const transformToCamelCase = (string) => {
+  const words = string.split(/[\s\-_]+/);
+  const camelCasedWords = words.map((word, index) => {
+    if (index === 0) {
+      return word[0].toUpperCase() + word.slice(1);
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  });
+  return camelCasedWords.join("");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFileHash,
+  transformToCamelCase
+});
+//# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import crypto from 'crypto-js';\n\nexport const getFileHash = (filePath: string) => {\n  const hash = crypto.SHA3(filePath);\n\n  return hash\n    .toString(crypto.enc.Base64)\n    .replace(/[^A-Z\\d]/gi, '')\n    .substring(0, 20);\n};\n\nexport const transformToCamelCase = (string: string): string => {\n  // Split the string into words using a regex that finds spaces, hyphens, and underscores\n  const words = string.split(/[\\s\\-_]+/);\n\n  // Transform each word except the first to have its first letter uppercase\n  const camelCasedWords = words.map((word, index) => {\n    if (index === 0) {\n      return word[0].toUpperCase() + word.slice(1);\n    }\n    return word.charAt(0).toUpperCase() + word.slice(1);\n  });\n\n  // Join the words back together\n  return camelCasedWords.join('');\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAmB;AAEZ,MAAM,cAAc,CAAC,aAAqB;AAC/C,QAAM,OAAO,iBAAAA,QAAO,KAAK,QAAQ;AAEjC,SAAO,KACJ,SAAS,iBAAAA,QAAO,IAAI,MAAM,EAC1B,QAAQ,cAAc,EAAE,EACxB,UAAU,GAAG,EAAE;AACpB;AAEO,MAAM,uBAAuB,CAAC,WAA2B;AAE9D,QAAM,QAAQ,OAAO,MAAM,UAAU;AAGrC,QAAM,kBAAkB,MAAM,IAAI,CAAC,MAAM,UAAU;AACjD,QAAI,UAAU,GAAG;AACf,aAAO,KAAK,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,IAC7C;AACA,WAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AAAA,EACpD,CAAC;AAGD,SAAO,gBAAgB,KAAK,EAAE;AAChC;","names":["crypto"]}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,4 @@
+declare const getFileHash: (filePath: string) => string;
+declare const transformToCamelCase: (string: string) => string;
+
+export { getFileHash, transformToCamelCase };

package/dist/esm/chokidar/index.d.mts

@@ -0,0 +1,2 @@
+export { watch } from './watcher.mjs';
+import 'chokidar';

package/dist/esm/chokidar/index.mjs

@@ -0,0 +1,2 @@
+export * from './watcher.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/chokidar/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/chokidar/index.ts"],"sourcesContent":["export * from './watcher';\n"],"mappings":"AAAA,cAAc;","names":[]}

package/dist/esm/chokidar/watcher.d.mts

@@ -0,0 +1,5 @@
+import chokidar, { WatchOptions } from 'chokidar';
+
+declare const watch: (options?: WatchOptions) => chokidar.FSWatcher;
+
+export { watch };

package/dist/esm/chokidar/watcher.mjs

@@ -0,0 +1,58 @@
+import { relative } from "path";
+import { getConfiguration } from "@intlayer/config";
+import chokidar from "chokidar";
+import { sync } from "glob";
+import { createDictionaryList } from '../transpiler/dictionary_to_main/createDictionaryList.mjs';
+import {
+  createTypes,
+  createModuleAugmentation
+} from '../transpiler/dictionary_to_type/index.mjs';
+import { transpileContentDeclaration } from '../transpiler/intlater_module_to_dictionary/transpileContentDeclaration.mjs';
+const watch = (options) => {
+  const { content } = getConfiguration({
+    verbose: true
+  });
+  const { watchedFilesPatternWithPath, baseDir } = content;
+  const files = sync(watchedFilesPatternWithPath);
+  return chokidar.watch(watchedFilesPatternWithPath, {
+    persistent: true,
+    // Make the watcher persistent
+    ignoreInitial: true,
+    // Process existing files
+    ...options
+  }).on("ready", async () => {
+    const dictionariesPaths = await transpileContentDeclaration(files);
+    console.info("Building Intlayer types...");
+    createTypes(dictionariesPaths);
+    console.info("Building Intlayer module augmentation...");
+    createModuleAugmentation();
+    console.info("Building Intlayer dictionary list...");
+    createDictionaryList();
+    const relativeDictionariesPath = dictionariesPaths.map(
+      (dictionary) => relative(baseDir, dictionary)
+    );
+    console.info("Dictionaries:", relativeDictionariesPath);
+  }).on("unlink", (filePath) => {
+    console.info("Removed file detected: ", relative(baseDir, filePath));
+  }).on("add", async (filePath) => {
+    console.info("Additional file detected: ", relative(baseDir, filePath));
+    const dictionaries = await transpileContentDeclaration(filePath);
+    console.info("Building TypeScript types...");
+    createTypes(dictionaries);
+    console.info("Building type index...");
+    createModuleAugmentation();
+    console.info("Building main...");
+    createDictionaryList();
+  }).on("change", async (filePath) => {
+    console.info("Change detected: ", relative(baseDir, filePath));
+    const dictionaries = await transpileContentDeclaration(filePath);
+    console.info("Building TypeScript types...");
+    createTypes(dictionaries);
+  }).on("error", (error) => {
+    console.error("Watcher error:", error);
+  });
+};
+export {
+  watch
+};
+//# sourceMappingURL=watcher.mjs.map

package/dist/esm/chokidar/watcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/chokidar/watcher.ts"],"sourcesContent":["import { relative } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport chokidar, { type WatchOptions } from 'chokidar';\nimport { sync } from 'glob';\nimport { createDictionaryList } from '../transpiler/dictionary_to_main/createDictionaryList';\nimport {\n  createTypes,\n  createModuleAugmentation,\n} from '../transpiler/dictionary_to_type/index';\nimport { transpileContentDeclaration } from '../transpiler/intlater_module_to_dictionary/transpileContentDeclaration';\n\n// Initialize chokidar watcher (non-persistent)\nexport const watch = (options?: WatchOptions) => {\n  const { content } = getConfiguration({\n    verbose: true,\n  });\n  const { watchedFilesPatternWithPath, baseDir } = content;\n\n  const files: string[] = sync(watchedFilesPatternWithPath);\n\n  return chokidar\n    .watch(watchedFilesPatternWithPath, {\n      persistent: true, // Make the watcher persistent\n      ignoreInitial: true, // Process existing files\n      ...options,\n    })\n    .on('ready', async () => {\n      const dictionariesPaths = await transpileContentDeclaration(files);\n\n      console.info('Building Intlayer types...');\n      createTypes(dictionariesPaths);\n\n      console.info('Building Intlayer module augmentation...');\n      createModuleAugmentation();\n\n      console.info('Building Intlayer dictionary list...');\n      createDictionaryList();\n\n      const relativeDictionariesPath = dictionariesPaths.map((dictionary) =>\n        relative(baseDir, dictionary)\n      );\n\n      console.info('Dictionaries:', relativeDictionariesPath);\n    })\n    .on('unlink', (filePath) => {\n      // Process the file with the functionToRun\n      console.info('Removed file detected: ', relative(baseDir, filePath));\n      // await transpileContentDeclaration(filePath);\n\n      // console.info('Building TypeScript types...');\n      // createTypes([filePath]);\n\n      // console.info('Building type index...');\n      // createModuleAugmentation();\n\n      // console.info('Building main...');\n      // createDictionaryList();\n    })\n    .on('add', async (filePath) => {\n      // Process the file with the functionToRun\n      console.info('Additional file detected: ', relative(baseDir, filePath));\n      const dictionaries = await transpileContentDeclaration(filePath);\n\n      console.info('Building TypeScript types...');\n      createTypes(dictionaries);\n\n      console.info('Building type index...');\n      createModuleAugmentation();\n\n      console.info('Building main...');\n      createDictionaryList();\n    })\n    .on('change', async (filePath) => {\n      // Process the file with the functionToRun\n      console.info('Change detected: ', relative(baseDir, filePath));\n      const dictionaries = await transpileContentDeclaration(filePath);\n\n      console.info('Building TypeScript types...');\n      createTypes(dictionaries);\n    })\n    .on('error', (error) => {\n      console.error('Watcher error:', error);\n    });\n};\n"],"mappings":"AAAA,SAAS,gBAAgB;AACzB,SAAS,wBAAwB;AACjC,OAAO,cAAqC;AAC5C,SAAS,YAAY;AACrB,SAAS,4BAA4B;AACrC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mCAAmC;AAGrC,MAAM,QAAQ,CAAC,YAA2B;AAC/C,QAAM,EAAE,QAAQ,IAAI,iBAAiB;AAAA,IACnC,SAAS;AAAA,EACX,CAAC;AACD,QAAM,EAAE,6BAA6B,QAAQ,IAAI;AAEjD,QAAM,QAAkB,KAAK,2BAA2B;AAExD,SAAO,SACJ,MAAM,6BAA6B;AAAA,IAClC,YAAY;AAAA;AAAA,IACZ,eAAe;AAAA;AAAA,IACf,GAAG;AAAA,EACL,CAAC,EACA,GAAG,SAAS,YAAY;AACvB,UAAM,oBAAoB,MAAM,4BAA4B,KAAK;AAEjE,YAAQ,KAAK,4BAA4B;AACzC,gBAAY,iBAAiB;AAE7B,YAAQ,KAAK,0CAA0C;AACvD,6BAAyB;AAEzB,YAAQ,KAAK,sCAAsC;AACnD,yBAAqB;AAErB,UAAM,2BAA2B,kBAAkB;AAAA,MAAI,CAAC,eACtD,SAAS,SAAS,UAAU;AAAA,IAC9B;AAEA,YAAQ,KAAK,iBAAiB,wBAAwB;AAAA,EACxD,CAAC,EACA,GAAG,UAAU,CAAC,aAAa;AAE1B,YAAQ,KAAK,2BAA2B,SAAS,SAAS,QAAQ,CAAC;AAAA,EAWrE,CAAC,EACA,GAAG,OAAO,OAAO,aAAa;AAE7B,YAAQ,KAAK,8BAA8B,SAAS,SAAS,QAAQ,CAAC;AACtE,UAAM,eAAe,MAAM,4BAA4B,QAAQ;AAE/D,YAAQ,KAAK,8BAA8B;AAC3C,gBAAY,YAAY;AAExB,YAAQ,KAAK,wBAAwB;AACrC,6BAAyB;AAEzB,YAAQ,KAAK,kBAAkB;AAC/B,yBAAqB;AAAA,EACvB,CAAC,EACA,GAAG,UAAU,OAAO,aAAa;AAEhC,YAAQ,KAAK,qBAAqB,SAAS,SAAS,QAAQ,CAAC;AAC7D,UAAM,eAAe,MAAM,4BAA4B,QAAQ;AAE/D,YAAQ,KAAK,8BAA8B;AAC3C,gBAAY,YAAY;AAAA,EAC1B,CAAC,EACA,GAAG,SAAS,CAAC,UAAU;AACtB,YAAQ,MAAM,kBAAkB,KAAK;AAAA,EACvC,CAAC;AACL;","names":[]}

package/dist/esm/index.d.mts

@@ -0,0 +1,4 @@
+export { watch } from './chokidar/watcher.mjs';
+export { createDictionaryList } from './transpiler/dictionary_to_main/createDictionaryList.mjs';
+export { createModuleAugmentation } from './transpiler/dictionary_to_type/createModuleAugmentation.mjs';
+import 'chokidar';

package/dist/esm/index.mjs

@@ -0,0 +1,9 @@
+import { watch } from './chokidar/watcher.mjs';
+import { createDictionaryList } from './transpiler/dictionary_to_main/createDictionaryList.mjs';
+import { createModuleAugmentation } from './transpiler/dictionary_to_type/createModuleAugmentation.mjs';
+export {
+  createDictionaryList,
+  createModuleAugmentation,
+  watch
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export { watch } from './chokidar/watcher';\nexport { createDictionaryList } from './transpiler/dictionary_to_main/createDictionaryList';\nexport { createModuleAugmentation } from './transpiler/dictionary_to_type/createModuleAugmentation';\n"],"mappings":"AAAA,SAAS,aAAa;AACtB,SAAS,4BAA4B;AACrC,SAAS,gCAAgC;","names":[]}

package/dist/esm/transpiler/dictionary_to_main/createDictionaryList.d.mts

@@ -0,0 +1,6 @@
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+declare const createDictionaryList: () => void;
+
+export { createDictionaryList };