@intlayer/chokidar 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Sébastien Vanvelthem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/chokidar/index.cjs

@@ -0,0 +1,23 @@
+"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 chokidar_exports = {};
+module.exports = __toCommonJS(chokidar_exports);
+__reExport(chokidar_exports, require('./watcher.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./watcher.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/chokidar/index.cjs.map

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

package/dist/cjs/chokidar/index.d.ts

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

package/dist/cjs/chokidar/watcher.cjs

@@ -0,0 +1,89 @@
+"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 watcher_exports = {};
+__export(watcher_exports, {
+  watch: () => watch
+});
+module.exports = __toCommonJS(watcher_exports);
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_chokidar = __toESM(require("chokidar"));
+var import_glob = require("glob");
+var import_createDictionaryList = require('../transpiler/dictionary_to_main/createDictionaryList.cjs');
+var import_dictionary_to_type = require('../transpiler/dictionary_to_type/index.cjs');
+var import_transpileContentDeclaration = require('../transpiler/intlater_module_to_dictionary/transpileContentDeclaration.cjs');
+const watch = (options) => {
+  const { content } = (0, import_config.getConfiguration)({
+    verbose: true
+  });
+  const { watchedFilesPatternWithPath, baseDir } = content;
+  const files = (0, import_glob.sync)(watchedFilesPatternWithPath);
+  return import_chokidar.default.watch(watchedFilesPatternWithPath, {
+    persistent: true,
+    // Make the watcher persistent
+    ignoreInitial: true,
+    // Process existing files
+    ...options
+  }).on("ready", async () => {
+    const dictionariesPaths = await (0, import_transpileContentDeclaration.transpileContentDeclaration)(files);
+    console.info("Building Intlayer types...");
+    (0, import_dictionary_to_type.createTypes)(dictionariesPaths);
+    console.info("Building Intlayer module augmentation...");
+    (0, import_dictionary_to_type.createModuleAugmentation)();
+    console.info("Building Intlayer dictionary list...");
+    (0, import_createDictionaryList.createDictionaryList)();
+    const relativeDictionariesPath = dictionariesPaths.map(
+      (dictionary) => (0, import_path.relative)(baseDir, dictionary)
+    );
+    console.info("Dictionaries:", relativeDictionariesPath);
+  }).on("unlink", (filePath) => {
+    console.info("Removed file detected: ", (0, import_path.relative)(baseDir, filePath));
+  }).on("add", async (filePath) => {
+    console.info("Additional file detected: ", (0, import_path.relative)(baseDir, filePath));
+    const dictionaries = await (0, import_transpileContentDeclaration.transpileContentDeclaration)(filePath);
+    console.info("Building TypeScript types...");
+    (0, import_dictionary_to_type.createTypes)(dictionaries);
+    console.info("Building type index...");
+    (0, import_dictionary_to_type.createModuleAugmentation)();
+    console.info("Building main...");
+    (0, import_createDictionaryList.createDictionaryList)();
+  }).on("change", async (filePath) => {
+    console.info("Change detected: ", (0, import_path.relative)(baseDir, filePath));
+    const dictionaries = await (0, import_transpileContentDeclaration.transpileContentDeclaration)(filePath);
+    console.info("Building TypeScript types...");
+    (0, import_dictionary_to_type.createTypes)(dictionaries);
+  }).on("error", (error) => {
+    console.error("Watcher error:", error);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  watch
+});
+//# sourceMappingURL=watcher.cjs.map

package/dist/cjs/chokidar/watcher.cjs.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;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAyB;AACzB,oBAAiC;AACjC,sBAA4C;AAC5C,kBAAqB;AACrB,kCAAqC;AACrC,gCAGO;AACP,yCAA4C;AAGrC,MAAM,QAAQ,CAAC,YAA2B;AAC/C,QAAM,EAAE,QAAQ,QAAI,gCAAiB;AAAA,IACnC,SAAS;AAAA,EACX,CAAC;AACD,QAAM,EAAE,6BAA6B,QAAQ,IAAI;AAEjD,QAAM,YAAkB,kBAAK,2BAA2B;AAExD,SAAO,gBAAAA,QACJ,MAAM,6BAA6B;AAAA,IAClC,YAAY;AAAA;AAAA,IACZ,eAAe;AAAA;AAAA,IACf,GAAG;AAAA,EACL,CAAC,EACA,GAAG,SAAS,YAAY;AACvB,UAAM,oBAAoB,UAAM,gEAA4B,KAAK;AAEjE,YAAQ,KAAK,4BAA4B;AACzC,+CAAY,iBAAiB;AAE7B,YAAQ,KAAK,0CAA0C;AACvD,4DAAyB;AAEzB,YAAQ,KAAK,sCAAsC;AACnD,0DAAqB;AAErB,UAAM,2BAA2B,kBAAkB;AAAA,MAAI,CAAC,mBACtD,sBAAS,SAAS,UAAU;AAAA,IAC9B;AAEA,YAAQ,KAAK,iBAAiB,wBAAwB;AAAA,EACxD,CAAC,EACA,GAAG,UAAU,CAAC,aAAa;AAE1B,YAAQ,KAAK,+BAA2B,sBAAS,SAAS,QAAQ,CAAC;AAAA,EAWrE,CAAC,EACA,GAAG,OAAO,OAAO,aAAa;AAE7B,YAAQ,KAAK,kCAA8B,sBAAS,SAAS,QAAQ,CAAC;AACtE,UAAM,eAAe,UAAM,gEAA4B,QAAQ;AAE/D,YAAQ,KAAK,8BAA8B;AAC3C,+CAAY,YAAY;AAExB,YAAQ,KAAK,wBAAwB;AACrC,4DAAyB;AAEzB,YAAQ,KAAK,kBAAkB;AAC/B,0DAAqB;AAAA,EACvB,CAAC,EACA,GAAG,UAAU,OAAO,aAAa;AAEhC,YAAQ,KAAK,yBAAqB,sBAAS,SAAS,QAAQ,CAAC;AAC7D,UAAM,eAAe,UAAM,gEAA4B,QAAQ;AAE/D,YAAQ,KAAK,8BAA8B;AAC3C,+CAAY,YAAY;AAAA,EAC1B,CAAC,EACA,GAAG,SAAS,CAAC,UAAU;AACtB,YAAQ,MAAM,kBAAkB,KAAK;AAAA,EACvC,CAAC;AACL;","names":["chokidar"]}

package/dist/cjs/chokidar/watcher.d.ts

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

package/dist/cjs/index.cjs

@@ -0,0 +1,35 @@
+"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 src_exports = {};
+__export(src_exports, {
+  createDictionaryList: () => import_createDictionaryList.createDictionaryList,
+  createModuleAugmentation: () => import_createModuleAugmentation.createModuleAugmentation,
+  watch: () => import_watcher.watch
+});
+module.exports = __toCommonJS(src_exports);
+var import_watcher = require('./chokidar/watcher.cjs');
+var import_createDictionaryList = require('./transpiler/dictionary_to_main/createDictionaryList.cjs');
+var import_createModuleAugmentation = require('./transpiler/dictionary_to_type/createModuleAugmentation.cjs');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDictionaryList,
+  createModuleAugmentation,
+  watch
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAsB;AACtB,kCAAqC;AACrC,sCAAyC;","names":[]}

package/dist/cjs/index.d.ts

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

package/dist/cjs/transpiler/dictionary_to_main/createDictionaryList.cjs

@@ -0,0 +1,76 @@
+"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 createDictionaryList_exports = {};
+__export(createDictionaryList_exports, {
+  createDictionaryList: () => createDictionaryList
+});
+module.exports = __toCommonJS(createDictionaryList_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_glob = require("glob");
+var import_utils = require('../../utils.cjs');
+const { content } = (0, import_config.getConfiguration)();
+const { dictionariesDir, mainDir } = content;
+const generateDictionaryListContent = (dictionaries, format = "esm") => {
+  let content2 = "";
+  const dictionariesRef = dictionaries.map((dictionaryPath) => ({
+    relativePath: (0, import_path.relative)(mainDir, dictionaryPath),
+    id: (0, import_path.basename)(dictionaryPath, (0, import_path.extname)(dictionaryPath)),
+    // Get the base name as the dictionary id
+    hash: `_${(0, import_utils.getFileHash)(dictionaryPath)}`
+    // Get the hash of the dictionary to avoid conflicts
+  }));
+  dictionariesRef.forEach((dictionary) => {
+    if (format === "esm")
+      content2 += `import ${dictionary.hash} from '${dictionary.relativePath}';
+`;
+    if (format === "cjs")
+      content2 += `const ${dictionary.hash} = require('${dictionary.relativePath}');
+`;
+  });
+  content2 += "\n";
+  const formattedDictionaryMap = dictionariesRef.map((dictionary) => `"${dictionary.id}": ${dictionary.hash}`).join(",\n");
+  if (format === "esm")
+    content2 += `export default {
+${formattedDictionaryMap}
+};
+`;
+  if (format === "cjs")
+    content2 += `module.exports = {
+${formattedDictionaryMap}
+};
+`;
+  return content2;
+};
+const createDictionaryList = () => {
+  if (!(0, import_fs.existsSync)(mainDir)) {
+    (0, import_fs.mkdirSync)(mainDir, { recursive: true });
+  }
+  const dictionaries = (0, import_glob.sync)(`${dictionariesDir}/**/*.json`);
+  const cjsContent = generateDictionaryListContent(dictionaries, "cjs");
+  (0, import_fs.writeFileSync)((0, import_path.resolve)(mainDir, "dictionaries.cjs"), cjsContent);
+  const esmContent = generateDictionaryListContent(dictionaries, "esm");
+  (0, import_fs.writeFileSync)((0, import_path.resolve)(mainDir, "dictionaries.mjs"), esmContent);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDictionaryList
+});
+//# sourceMappingURL=createDictionaryList.cjs.map

package/dist/cjs/transpiler/dictionary_to_main/createDictionaryList.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_main/createDictionaryList.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { basename, extname, relative, resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport { getFileHash } from '../../utils';\n\nconst { content } = getConfiguration();\nconst { dictionariesDir, mainDir } = content;\n\n/**\n * This function generates the content of the dictionary list file\n */\nconst generateDictionaryListContent = (\n  dictionaries: string[],\n  format: 'cjs' | 'esm' = 'esm'\n): string => {\n  let content = '';\n\n  const dictionariesRef = dictionaries.map((dictionaryPath) => ({\n    relativePath: relative(mainDir, dictionaryPath),\n    id: basename(dictionaryPath, extname(dictionaryPath)), // Get the base name as the dictionary id\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    if (format === 'esm')\n      content += `import ${dictionary.hash} from '${dictionary.relativePath}';\\n`;\n    if (format === 'cjs')\n      content += `const ${dictionary.hash} = require('${dictionary.relativePath}');\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `\"${dictionary.id}\": ${dictionary.hash}`)\n    .join(',\\n');\n\n  if (format === 'esm')\n    content += `export default {\\n${formattedDictionaryMap}\\n};\\n`;\n  if (format === 'cjs')\n    content += `module.exports = {\\n${formattedDictionaryMap}\\n};\\n`;\n\n  return content;\n};\n\n/**\n * This function generates a list of dictionaries in the main directory\n */\nexport const createDictionaryList = () => {\n  // Create main directory if it doesn't exist\n  if (!existsSync(mainDir)) {\n    mkdirSync(mainDir, { recursive: true });\n  }\n\n  const dictionaries: string[] = sync(`${dictionariesDir}/**/*.json`);\n\n  // Create the dictionary list file\n  const cjsContent = generateDictionaryListContent(dictionaries, 'cjs');\n  writeFileSync(resolve(mainDir, 'dictionaries.cjs'), cjsContent);\n\n  const esmContent = generateDictionaryListContent(dictionaries, 'esm');\n  writeFileSync(resolve(mainDir, 'dictionaries.mjs'), esmContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAqD;AACrD,oBAAiC;AACjC,kBAAqB;AACrB,mBAA4B;AAE5B,MAAM,EAAE,QAAQ,QAAI,gCAAiB;AACrC,MAAM,EAAE,iBAAiB,QAAQ,IAAI;AAKrC,MAAM,gCAAgC,CACpC,cACA,SAAwB,UACb;AACX,MAAIA,WAAU;AAEd,QAAM,kBAAkB,aAAa,IAAI,CAAC,oBAAoB;AAAA,IAC5D,kBAAc,sBAAS,SAAS,cAAc;AAAA,IAC9C,QAAI,sBAAS,oBAAgB,qBAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,QAAI,0BAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,QAAI,WAAW;AACb,MAAAA,YAAW,UAAU,WAAW,IAAI,UAAU,WAAW,YAAY;AAAA;AACvE,QAAI,WAAW;AACb,MAAAA,YAAW,SAAS,WAAW,IAAI,eAAe,WAAW,YAAY;AAAA;AAAA,EAC7E,CAAC;AAED,EAAAA,YAAW;AAGX,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,IAAI,WAAW,EAAE,MAAM,WAAW,IAAI,EAAE,EAC5D,KAAK,KAAK;AAEb,MAAI,WAAW;AACb,IAAAA,YAAW;AAAA,EAAqB,sBAAsB;AAAA;AAAA;AACxD,MAAI,WAAW;AACb,IAAAA,YAAW;AAAA,EAAuB,sBAAsB;AAAA;AAAA;AAE1D,SAAOA;AACT;AAKO,MAAM,uBAAuB,MAAM;AAExC,MAAI,KAAC,sBAAW,OAAO,GAAG;AACxB,6BAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,mBAAyB,kBAAK,GAAG,eAAe,YAAY;AAGlE,QAAM,aAAa,8BAA8B,cAAc,KAAK;AACpE,mCAAc,qBAAQ,SAAS,kBAAkB,GAAG,UAAU;AAE9D,QAAM,aAAa,8BAA8B,cAAc,KAAK;AACpE,mCAAc,qBAAQ,SAAS,kBAAkB,GAAG,UAAU;AAChE;","names":["content"]}

package/dist/cjs/transpiler/dictionary_to_main/createDictionaryList.d.ts

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

package/dist/cjs/transpiler/dictionary_to_main/index.cjs

@@ -0,0 +1,23 @@
+"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 dictionary_to_main_exports = {};
+module.exports = __toCommonJS(dictionary_to_main_exports);
+__reExport(dictionary_to_main_exports, require('./createDictionaryList.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./createDictionaryList.cjs')
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_main/index.ts"],"sourcesContent":["export * from './createDictionaryList';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,uCAAc,mCAAd;","names":[]}

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

@@ -0,0 +1 @@
+export { createDictionaryList } from './createDictionaryList.js';

package/dist/cjs/transpiler/dictionary_to_type/createModuleAugmentation.cjs

@@ -0,0 +1,87 @@
+"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 createModuleAugmentation_exports = {};
+__export(createModuleAugmentation_exports, {
+  createModuleAugmentation: () => createModuleAugmentation,
+  getTypeName: () => getTypeName
+});
+module.exports = __toCommonJS(createModuleAugmentation_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_glob = require("glob");
+var import_utils = require('../../utils.cjs');
+const { content, internationalization } = (0, import_config.getConfiguration)();
+const { typesDir, moduleAugmentationDir } = content;
+const { locales } = internationalization;
+const getTypeName = (id) => (0, import_utils.transformToCamelCase)(`${id}Content`);
+const generateTypeIndexContent = (typeFiles) => {
+  let content2 = "/* eslint-disable */\nimport 'intlayer';\nimport { Locales } from '@intlayer/config'\n";
+  const dictionariesRef = typeFiles.map((dictionaryPath) => ({
+    relativePath: (0, import_path.relative)(moduleAugmentationDir, dictionaryPath),
+    id: (0, import_path.basename)(dictionaryPath, ".d.ts"),
+    // Get the base name as the dictionary id
+    hash: `_${(0, import_utils.getFileHash)(dictionaryPath)}`
+    // Get the hash of the dictionary to avoid conflicts
+  }));
+  dictionariesRef.forEach((dictionary) => {
+    const typeName = getTypeName(dictionary.id);
+    content2 += `import type { ${typeName} as ${dictionary.hash} } from '${dictionary.relativePath}';
+`;
+  });
+  content2 += "\n";
+  const formattedDictionaryMap = dictionariesRef.map((dictionary) => `    "${dictionary.id}": ${dictionary.hash};`).join("\n");
+  const formatLocales = locales.map((locale) => {
+    for (const key in import_config.Locales) {
+      if (import_config.Locales[key] === locale) {
+        return `    ${key} = '${locale}'`;
+      }
+    }
+  }).join(",\n");
+  content2 += `declare module 'intlayer' {
+`;
+  content2 += `  interface IntlayerDictionaryTypesConnector {
+${formattedDictionaryMap}
+  }
+
+`;
+  content2 += `  enum ConfigLocales {
+${formatLocales}
+  };
+
+`;
+  content2 += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}
+`;
+  content2 += `};`;
+  return content2;
+};
+const createModuleAugmentation = () => {
+  if (!(0, import_fs.existsSync)(moduleAugmentationDir)) {
+    (0, import_fs.mkdirSync)(moduleAugmentationDir, { recursive: true });
+  }
+  const dictionaries = (0, import_glob.sync)(`${typesDir}/**/*.d.ts`);
+  const tsContent = generateTypeIndexContent(dictionaries);
+  (0, import_fs.writeFileSync)((0, import_path.join)(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createModuleAugmentation,
+  getTypeName
+});
+//# sourceMappingURL=createModuleAugmentation.cjs.map

package/dist/cjs/transpiler/dictionary_to_type/createModuleAugmentation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createModuleAugmentation.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { basename, join, relative } from 'path';\nimport { Locales, getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport { getFileHash, transformToCamelCase } from '../../utils';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\nconst { locales } = internationalization;\n\nexport const getTypeName = (id: string): string =>\n  transformToCamelCase(`${id}Content`);\n\n/**\n * This function generates the content of the module augmentation file\n */\nconst generateTypeIndexContent = (typeFiles: string[]): string => {\n  let content =\n    \"/* eslint-disable */\\nimport 'intlayer';\\nimport { Locales } from '@intlayer/config'\\n\";\n\n  const dictionariesRef = typeFiles.map((dictionaryPath) => ({\n    relativePath: relative(moduleAugmentationDir, dictionaryPath),\n    id: basename(dictionaryPath, '.d.ts'), // Get the base name as the dictionary id\n    hash: `_${getFileHash(dictionaryPath)}`, // Get the hash of the dictionary to avoid conflicts\n  }));\n\n  // Import all dictionaries\n  dictionariesRef.forEach((dictionary) => {\n    const typeName = getTypeName(dictionary.id);\n    content += `import type { ${typeName} as ${dictionary.hash} } from '${dictionary.relativePath}';\\n`;\n  });\n\n  content += '\\n';\n\n  // Format Dictionary Map\n  const formattedDictionaryMap: string = dictionariesRef\n    .map((dictionary) => `    \"${dictionary.id}\": ${dictionary.hash};`)\n    .join('\\n');\n\n  const formatLocales = locales\n    .map((locale) => {\n      for (const key in Locales) {\n        if (Locales[key as keyof typeof Locales] === locale) {\n          return `    ${key} = '${locale}'`;\n        }\n      }\n    })\n    .join(',\\n');\n\n  /**\n   * Write the module augmentation to extend the intlayer module with the dictionaries types\n   * Will suggest the type resulting of the dictionaries\n   *\n   * declare module 'intlayer' {\n   *   interface IntlayerDictionaryTypesConnector = {\n   *     dictionaries: {\n   *       id: DictionaryType;\n   *     }\n   *   }\n   *\n   *   enum ConfigLocales {\n   *     ENGLISH = 'en',\n   *     FRENCH = 'fr',\n   *     SPANISH = 'es',\n   *   }\n   *\n   *   interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\n   *\n   * }\n   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  content += `declare module 'intlayer' {\\n`;\n  content += `  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  }\\n\\n`;\n  content += `  enum ConfigLocales {\\n${formatLocales}\\n  };\\n\\n`;\n  content += `  interface IConfigLocales<Content> extends Record<ConfigLocales, Content> {}\\n`;\n  content += `};`;\n\n  return content;\n};\n\n/**\n * This function generates a index file merging all the types\n */\nexport const createModuleAugmentation = () => {\n  // Create main directory if it doesn't exist\n  if (!existsSync(moduleAugmentationDir)) {\n    mkdirSync(moduleAugmentationDir, { recursive: true });\n  }\n\n  const dictionaries: string[] = sync(`${typesDir}/**/*.d.ts`);\n  // Create the dictionary list file\n\n  const tsContent = generateTypeIndexContent(dictionaries);\n  writeFileSync(join(moduleAugmentationDir, 'intlayer.d.ts'), tsContent);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,kBAAyC;AACzC,oBAA0C;AAC1C,kBAAqB;AACrB,mBAAkD;AAElD,MAAM,EAAE,SAAS,qBAAqB,QAAI,gCAAiB;AAC3D,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAC5C,MAAM,EAAE,QAAQ,IAAI;AAEb,MAAM,cAAc,CAAC,WAC1B,mCAAqB,GAAG,EAAE,SAAS;AAKrC,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WACF;AAEF,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,kBAAc,sBAAS,uBAAuB,cAAc;AAAA,IAC5D,QAAI,sBAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,QAAI,0BAAY,cAAc,CAAC;AAAA;AAAA,EACvC,EAAE;AAGF,kBAAgB,QAAQ,CAAC,eAAe;AACtC,UAAM,WAAW,YAAY,WAAW,EAAE;AAC1C,IAAAA,YAAW,iBAAiB,QAAQ,OAAO,WAAW,IAAI,YAAY,WAAW,YAAY;AAAA;AAAA,EAC/F,CAAC;AAED,EAAAA,YAAW;AAGX,QAAM,yBAAiC,gBACpC,IAAI,CAAC,eAAe,QAAQ,WAAW,EAAE,MAAM,WAAW,IAAI,GAAG,EACjE,KAAK,IAAI;AAEZ,QAAM,gBAAgB,QACnB,IAAI,CAAC,WAAW;AACf,eAAW,OAAO,uBAAS;AACzB,UAAI,sBAAQ,GAA2B,MAAM,QAAQ;AACnD,eAAO,OAAO,GAAG,OAAO,MAAM;AAAA,MAChC;AAAA,IACF;AAAA,EACF,CAAC,EACA,KAAK,KAAK;AAwBb,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAAA,EAAmD,sBAAsB;AAAA;AAAA;AAAA;AACpF,EAAAA,YAAW;AAAA,EAA2B,aAAa;AAAA;AAAA;AAAA;AACnD,EAAAA,YAAW;AAAA;AACX,EAAAA,YAAW;AAEX,SAAOA;AACT;AAKO,MAAM,2BAA2B,MAAM;AAE5C,MAAI,KAAC,sBAAW,qBAAqB,GAAG;AACtC,6BAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,mBAAyB,kBAAK,GAAG,QAAQ,YAAY;AAG3D,QAAM,YAAY,yBAAyB,YAAY;AACvD,mCAAc,kBAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content"]}

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

@@ -0,0 +1,7 @@
+declare const getTypeName: (id: string) => string;
+/**
+ * This function generates a index file merging all the types
+ */
+declare const createModuleAugmentation: () => void;
+
+export { createModuleAugmentation, getTypeName };

package/dist/cjs/transpiler/dictionary_to_type/createType.cjs

@@ -0,0 +1,114 @@
+"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 createType_exports = {};
+__export(createType_exports, {
+  createTypes: () => createTypes,
+  generateTypeScriptType: () => generateTypeScriptType,
+  generateTypeScriptTypeContent: () => generateTypeScriptTypeContent
+});
+module.exports = __toCommonJS(createType_exports);
+var import_fs = require("fs");
+var import_module = require("module");
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_core = require("@intlayer/core");
+var import_createModuleAugmentation = require('./createModuleAugmentation.cjs');
+const import_meta = {};
+const { content, internationalization } = (0, import_config.getConfiguration)();
+const { typesDir } = content;
+const isESModule = typeof import_meta.url === "string";
+const requireFunction = isESModule ? (0, import_module.createRequire)(import_meta.url) : require;
+const generateTypeScriptType = (obj) => {
+  let typeDefinition = ``;
+  const typeName = (0, import_createModuleAugmentation.getTypeName)(obj.id);
+  typeDefinition += `export type ${typeName} = {
+`;
+  typeDefinition += generateTypeScriptTypeContent(obj);
+  typeDefinition += "};\n\n";
+  return typeDefinition;
+};
+const generateTypeScriptTypeContent = (obj) => {
+  let typeDefinition = ``;
+  for (const [key, value] of Object.entries(obj)) {
+    const nodeType = value.nodeType;
+    if (
+      // Check if the value is a typed node
+      typeof value === "object" && nodeType === import_core.NodeType.Translation
+    ) {
+      const tsType = typeof value?.[internationalization.defaultLocale];
+      typeDefinition += `  ${key}: ${tsType},
+`;
+    } else if (
+      // Check if the value is a typed node
+      typeof value === "object" && nodeType === import_core.NodeType.Enumeration
+    ) {
+      const tsType = typeof value?.[internationalization.defaultLocale];
+      typeDefinition += `  ${key}: (quantity: number) => ${tsType},
+`;
+    } else if (
+      // Check if the value is a nested object
+      typeof value === "object" && !Array.isArray(value)
+    ) {
+      const nestedType = generateTypeScriptTypeContent(value);
+      typeDefinition += `  ${key}: {${nestedType}},
+`;
+    } else if (
+      // Check if the value is an array
+      Array.isArray(value)
+    ) {
+      const arrayType = typeof value[0];
+      typeDefinition += `  ${key}: ${arrayType}[],
+`;
+    } else if (
+      // Check if the value is an 'id'
+      typeof value === "string" && key === "id"
+    ) {
+      const tsType = `"${value}"`;
+      typeDefinition += `  ${key}: ${tsType},
+`;
+    } else {
+      const tsType = typeof value;
+      typeDefinition += `  ${key}: ${tsType},
+`;
+    }
+  }
+  return typeDefinition;
+};
+const createTypes = (dictionariesPaths) => {
+  const resultTypesPaths = [];
+  if (!(0, import_fs.existsSync)(typesDir)) {
+    (0, import_fs.mkdirSync)(typesDir, { recursive: true });
+  }
+  for (const dictionaryPath of dictionariesPaths) {
+    const contentModule = requireFunction(dictionaryPath);
+    const dictionaryName = contentModule.id;
+    const typeDefinition = generateTypeScriptType(contentModule);
+    const outputPath = (0, import_path.resolve)(typesDir, `${dictionaryName}.d.ts`);
+    (0, import_fs.writeFileSync)(outputPath, typeDefinition);
+    resultTypesPaths.push(outputPath);
+  }
+  return resultTypesPaths;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTypes,
+  generateTypeScriptType,
+  generateTypeScriptTypeContent
+});
+//# sourceMappingURL=createType.cjs.map

package/dist/cjs/transpiler/dictionary_to_type/createType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\nimport { createRequire } from 'module';\nimport { resolve } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport {\n  NodeType,\n  type Content,\n  type ContentModule,\n  type TypedNode,\n} from '@intlayer/core';\nimport { getTypeName } from './createModuleAugmentation';\n\nconst { content, internationalization } = getConfiguration();\nconst { typesDir } = content;\n\nconst isESModule = typeof import.meta.url === 'string';\nconst requireFunction = isESModule ? createRequire(import.meta.url) : require;\n\n/**\n *\n * This function generates a TypeScript type definition from a JSON object\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 *  }\n * };\n *\n * const result = generateTypeScriptType(input, 'RootObject');\n * console.log(result);\n *\n * Output:\n *\n * type RootObject = {\n *  id: '1',\n *  name: string,\n *  address: {\n *      id: '2',\n *      street: string,\n *      city: string,\n *  },\n * };\n *\n */\nexport const generateTypeScriptType = (obj: ContentModule): string => {\n  let typeDefinition = ``;\n\n  const typeName = getTypeName(obj.id);\n\n  typeDefinition += `export type ${typeName} = {\\n`;\n  typeDefinition += generateTypeScriptTypeContent(obj);\n  typeDefinition += '};\\n\\n';\n\n  return typeDefinition;\n};\n\nexport const generateTypeScriptTypeContent = (obj: Content): string => {\n  let typeDefinition = ``;\n\n  for (const [key, value] of Object.entries(obj)) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const nodeType: NodeType | undefined = (value as TypedNode).nodeType;\n    type ValueKey = keyof typeof value;\n\n    if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Translation\n    ) {\n      const tsType =\n        typeof value?.[internationalization.defaultLocale as ValueKey];\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else if (\n      // Check if the value is a typed node\n      typeof value === 'object' &&\n      nodeType === NodeType.Enumeration\n    ) {\n      const tsType =\n        typeof value?.[internationalization.defaultLocale as ValueKey];\n\n      typeDefinition += `  ${key}: (quantity: number) => ${tsType},\\n`;\n    } else if (\n      // Check if the value is a nested object\n      typeof value === 'object' &&\n      !Array.isArray(value)\n    ) {\n      // Nested object, recurse\n      const nestedType = generateTypeScriptTypeContent(value as Content);\n      typeDefinition += `  ${key}: {${nestedType}},\\n`;\n    } else if (\n      // Check if the value is an array\n      Array.isArray(value)\n    ) {\n      // Array handling (simplified, assumes non-empty arrays with uniform type)\n      const arrayType = typeof value[0];\n      typeDefinition += `  ${key}: ${arrayType}[],\\n`;\n    } else if (\n      // Check if the value is an 'id'\n      typeof value === 'string' &&\n      key === 'id'\n    ) {\n      // Special handling for 'id' field\n      const tsType = `\"${value}\"`;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    } else {\n      // Primitive type\n      const tsType = typeof value;\n      typeDefinition += `  ${key}: ${tsType},\\n`;\n    }\n  }\n\n  return typeDefinition;\n};\n\n/**\n * This function generates a TypeScript type definition from a JSON object\n */\nexport const createTypes = (dictionariesPaths: string[]): string[] => {\n  const resultTypesPaths: string[] = [];\n\n  // Create type folders if they don't exist\n  if (!existsSync(typesDir)) {\n    mkdirSync(typesDir, { recursive: true });\n  }\n\n  for (const dictionaryPath of dictionariesPaths) {\n    const contentModule: ContentModule = requireFunction(dictionaryPath);\n    const dictionaryName: string = contentModule.id;\n    const typeDefinition: string = generateTypeScriptType(contentModule);\n\n    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);\n\n    writeFileSync(outputPath, typeDefinition);\n\n    resultTypesPaths.push(outputPath);\n  }\n\n  return resultTypesPaths;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAqD;AACrD,oBAA8B;AAC9B,kBAAwB;AACxB,oBAAiC;AACjC,kBAKO;AACP,sCAA4B;AAV5B;AAYA,MAAM,EAAE,SAAS,qBAAqB,QAAI,gCAAiB;AAC3D,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,aAAa,OAAO,YAAY,QAAQ;AAC9C,MAAM,kBAAkB,iBAAa,6BAAc,YAAY,GAAG,IAAI;AAkC/D,MAAM,yBAAyB,CAAC,QAA+B;AACpE,MAAI,iBAAiB;AAErB,QAAM,eAAW,6CAAY,IAAI,EAAE;AAEnC,oBAAkB,eAAe,QAAQ;AAAA;AACzC,oBAAkB,8BAA8B,GAAG;AACnD,oBAAkB;AAElB,SAAO;AACT;AAEO,MAAM,gCAAgC,CAAC,QAAyB;AACrE,MAAI,iBAAiB;AAErB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAE9C,UAAM,WAAkC,MAAoB;AAG5D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,qBAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,QAAQ,qBAAqB,aAAyB;AAC/D,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,qBAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,QAAQ,qBAAqB,aAAyB;AAE/D,wBAAkB,KAAK,GAAG,2BAA2B,MAAM;AAAA;AAAA,IAC7D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,KAAK;AAAA,MACpB;AAEA,YAAM,aAAa,8BAA8B,KAAgB;AACjE,wBAAkB,KAAK,GAAG,MAAM,UAAU;AAAA;AAAA,IAC5C;AAAA;AAAA,MAEE,MAAM,QAAQ,KAAK;AAAA,MACnB;AAEA,YAAM,YAAY,OAAO,MAAM,CAAC;AAChC,wBAAkB,KAAK,GAAG,KAAK,SAAS;AAAA;AAAA,IAC1C;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,QAAQ;AAAA,MACR;AAEA,YAAM,SAAS,IAAI,KAAK;AACxB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC,OAAO;AAEL,YAAM,SAAS,OAAO;AACtB,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,cAAc,CAAC,sBAA0C;AACpE,QAAM,mBAA6B,CAAC;AAGpC,MAAI,KAAC,sBAAW,QAAQ,GAAG;AACzB,6BAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,gBAA+B,gBAAgB,cAAc;AACnE,UAAM,iBAAyB,cAAc;AAC7C,UAAM,iBAAyB,uBAAuB,aAAa;AAEnE,UAAM,iBAAa,qBAAQ,UAAU,GAAG,cAAc,OAAO;AAE7D,iCAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

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

@@ -0,0 +1,42 @@
+import { ContentModule, Content } from '@intlayer/core';
+
+/**
+ *
+ * This function generates a TypeScript type definition from a JSON object
+ *
+ * Example:
+ *
+ * const input = {
+ *  id: '1',
+ *  name: 'John Doe',
+ *  address: {
+ *      id: '2',
+ *      street: '123 Main St',
+ *      city: 'Springfield',
+ *  }
+ * };
+ *
+ * const result = generateTypeScriptType(input, 'RootObject');
+ * console.log(result);
+ *
+ * Output:
+ *
+ * type RootObject = {
+ *  id: '1',
+ *  name: string,
+ *  address: {
+ *      id: '2',
+ *      street: string,
+ *      city: string,
+ *  },
+ * };
+ *
+ */
+declare const generateTypeScriptType: (obj: ContentModule) => string;
+declare const generateTypeScriptTypeContent: (obj: Content) => string;
+/**
+ * This function generates a TypeScript type definition from a JSON object
+ */
+declare const createTypes: (dictionariesPaths: string[]) => string[];
+
+export { createTypes, generateTypeScriptType, generateTypeScriptTypeContent };

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

@@ -0,0 +1,25 @@
+"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 dictionary_to_type_exports = {};
+module.exports = __toCommonJS(dictionary_to_type_exports);
+__reExport(dictionary_to_type_exports, require('./createModuleAugmentation.cjs'), module.exports);
+__reExport(dictionary_to_type_exports, require('./createType.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./createModuleAugmentation.cjs'),
+  ...require('./createType.cjs')
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/index.ts"],"sourcesContent":["export * from './createModuleAugmentation';\nexport * from './createType';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,uCAAc,uCAAd;AACA,uCAAc,yBADd;","names":[]}