@intlayer/webpack 1.0.0

package/dist/cjs/webpack.config.cjs

@@ -0,0 +1,180 @@
+"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 webpack_config_exports = {};
+__export(webpack_config_exports, {
+  default: () => webpack_config_default,
+  devServerConfig: () => devServerConfig,
+  webpackConfig: () => webpackConfig,
+});
+module.exports = __toCommonJS(webpack_config_exports);
+var import_path = require("path");
+var import_config = require("@intlayer/config");
+var import_glob = require("glob");
+var import_utils = require("./utils.cjs");
+var import_webpack_plugin = require("./webpack-plugin.cjs");
+const { content } = (0, import_config.getConfiguration)({
+  verbose: true,
+});
+const { bundleDir, bundleFileExtension, watchedFilesPatternWithPath } = content;
+const getEntry = () =>
+  (0, import_glob.sync)(watchedFilesPatternWithPath).reduce((obj, el) => {
+    const hash = (0, import_utils.getFileHash)(el);
+    obj[hash] = el;
+    return obj;
+  }, {});
+const devServerConfig = {
+  // Enable hot module replacement
+  hot: true,
+  // Open the browser
+  open: false,
+  liveReload: false,
+  // Enable compression
+  compress: true,
+  // History API fallback
+  historyApiFallback: false,
+  // Host and port
+  host: "localhost",
+  port: 8080,
+  watchFiles: "./src/",
+  // watchedFilesPatternWithPath,
+  devMiddleware: {
+    // Enable write to disk to reuse the output
+    writeToDisk: true,
+  },
+  // Content base
+  static: {
+    directory: bundleDir,
+  },
+};
+const webpackConfig = {
+  // Define the environment mode (development or production)
+  mode: "production",
+  // or 'production'
+  // Entry point of the application
+  target: "node",
+  // Specifies the target environment
+  entry: getEntry,
+  output: {
+    clean: true,
+    // Clean the output directory before emit
+    library: "IntlLayerContent",
+    libraryTarget: "umd",
+    filename: `[name]${bundleFileExtension}`,
+    path: bundleDir,
+  },
+  cache: false,
+  // devtool: 'source-map',
+  // stats: {
+  //   preset: 'errors-only',
+  //   warnings: false,
+  // },
+  ignoreWarnings: [/./],
+  resolve: {
+    // Resolve TypeScript, JavaScript and JSON files
+    extensions: [".ts", ".js", ".json", ".wasm", ".ts", ".tsx", ".mjs", ".cjs"],
+    modules: [
+      // To find the loader module
+      (0, import_path.join)(__dirname, "..", "node_modules"),
+      // In the project node_modules
+      (0, import_path.join)(process.cwd(), "node_modules"),
+      // In the project node_modules
+      (0, import_path.join)(
+        process.cwd(),
+        "node_modules",
+        "intlayer-cli",
+        "node_modules"
+      ),
+      // Or via another project by importing intlayer
+      (0, import_path.join)(
+        process.cwd(),
+        "node_modules",
+        "intlayer-cli",
+        "node_modules",
+        "@intlayer/webpack",
+        "node_modules"
+      ),
+      // Or via another project by importing intlayer
+    ],
+  },
+  resolveLoader: {
+    // Configure how Webpack finds `loader` modules.
+    modules: [
+      // To find the loader module
+      (0, import_path.join)(process.cwd(), "node_modules"),
+      // In the project node_modules
+      (0, import_path.join)(
+        process.cwd(),
+        "node_modules",
+        "@intlayer/webpack",
+        "node_modules"
+      ),
+      // Or via another project by importing @intlayer/webpack
+      (0, import_path.join)(
+        process.cwd(),
+        "node_modules",
+        "intlayer-cli",
+        "node_modules",
+        "@intlayer/webpack",
+        "node_modules"
+      ),
+      // Or via another project by importing intlayer
+    ],
+    // roots: [
+    //   join(process.cwd()), // Project context
+    //   join(process.cwd(), '@intlayer/webpack'), // Or via CLI in another project
+    //   join(process.cwd(), 'intlayer', '@intlayer/webpack'), // Or via CLI in another project
+    // ],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.node$/,
+        loader: "node-loader",
+      },
+      // Use esbuild to compile JavaScript & TypeScript
+      {
+        // Match `.js`, `.jsx`, `.ts` or `.tsx` files
+        test: /\.[jt]sx?$/,
+        loader: "esbuild-loader",
+        options: {
+          // JavaScript version to compile to
+          target: "es2015",
+        },
+      },
+      // JSON files are supported natively by Webpack 5, no specific loader required
+    ],
+  },
+  devServer: devServerConfig,
+  plugins: [
+    new import_webpack_plugin.IntLayerPlugin(),
+    // new HotModuleReplacementPlugin()
+  ],
+};
+var webpack_config_default = webpackConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    devServerConfig,
+    webpackConfig,
+  });
+//# sourceMappingURL=webpack.config.cjs.map

package/dist/cjs/webpack.config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webpack.config.ts"],"sourcesContent":["import { join } from 'path';\nimport { getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport type { Configuration as WebPackConfiguration } from 'webpack';\nimport type { Configuration as DevServerConfiguration } from 'webpack-dev-server';\nimport { getFileHash } from './utils';\nimport { IntLayerPlugin } from './webpack-plugin';\n\nconst { content } = getConfiguration({\n  verbose: true,\n});\nconst { bundleDir, bundleFileExtension, watchedFilesPatternWithPath } = content;\n\nconst getEntry = (): Record<string, string> =>\n  sync(watchedFilesPatternWithPath).reduce(\n    (obj, el) => {\n      const hash = getFileHash(el);\n\n      obj[hash] = el;\n      return obj;\n    },\n    {} as Record<string, string>\n  );\n\n// For web interface\nexport const devServerConfig: DevServerConfiguration = {\n  // Enable hot module replacement\n  hot: true,\n  // Open the browser\n  open: false,\n  liveReload: false,\n\n  // Enable compression\n  compress: true,\n\n  // History API fallback\n  historyApiFallback: false,\n\n  // Host and port\n  host: 'localhost',\n  port: 8080,\n\n  watchFiles: './src/', // watchedFilesPatternWithPath,\n\n  devMiddleware: {\n    // Enable write to disk to reuse the output\n    writeToDisk: true,\n  },\n\n  // Content base\n  static: {\n    directory: bundleDir,\n  },\n};\n\nexport const webpackConfig: WebPackConfiguration = {\n  // Define the environment mode (development or production)\n  mode: 'production', // or 'production'\n  // Entry point of the application\n  target: 'node', // Specifies the target environment\n\n  entry: getEntry,\n  output: {\n    clean: true, // Clean the output directory before emit\n    library: 'IntlLayerContent',\n    libraryTarget: 'umd',\n    filename: `[name]${bundleFileExtension}`,\n    path: bundleDir,\n  },\n\n  cache: false,\n\n  // devtool: 'source-map',\n\n  // stats: {\n  //   preset: 'errors-only',\n  //   warnings: false,\n  // },\n  ignoreWarnings: [/./],\n  resolve: {\n    // Resolve TypeScript, JavaScript and JSON files\n    extensions: ['.ts', '.js', '.json', '.wasm', '.ts', '.tsx', '.mjs', '.cjs'],\n    modules: [\n      // To find the loader module\n      join(__dirname, '..', 'node_modules'), // In the project node_modules\n      join(process.cwd(), 'node_modules'), // In the project node_modules\n      join(process.cwd(), 'node_modules', 'intlayer-cli', 'node_modules'), // Or via another project by importing intlayer\n      join(\n        process.cwd(),\n        'node_modules',\n        'intlayer-cli',\n        'node_modules',\n        '@intlayer/webpack',\n        'node_modules'\n      ), // Or via another project by importing intlayer\n    ],\n  },\n\n  resolveLoader: {\n    // Configure how Webpack finds `loader` modules.\n    modules: [\n      // To find the loader module\n      join(process.cwd(), 'node_modules'), // In the project node_modules\n      join(process.cwd(), 'node_modules', '@intlayer/webpack', 'node_modules'), // Or via another project by importing @intlayer/webpack\n      join(\n        process.cwd(),\n        'node_modules',\n        'intlayer-cli',\n        'node_modules',\n        '@intlayer/webpack',\n        'node_modules'\n      ), // Or via another project by importing intlayer\n    ],\n    // roots: [\n    //   join(process.cwd()), // Project context\n    //   join(process.cwd(), '@intlayer/webpack'), // Or via CLI in another project\n    //   join(process.cwd(), 'intlayer', '@intlayer/webpack'), // Or via CLI in another project\n    // ],\n  },\n\n  module: {\n    rules: [\n      {\n        test: /\\.node$/,\n        loader: 'node-loader',\n      },\n      // Use esbuild to compile JavaScript & TypeScript\n      {\n        // Match `.js`, `.jsx`, `.ts` or `.tsx` files\n        test: /\\.[jt]sx?$/,\n        loader: 'esbuild-loader',\n        options: {\n          // JavaScript version to compile to\n          target: 'es2015',\n        },\n      },\n\n      // JSON files are supported natively by Webpack 5, no specific loader required\n    ],\n  },\n  devServer: devServerConfig,\n\n  plugins: [\n    new IntLayerPlugin(),\n    // new HotModuleReplacementPlugin()\n  ],\n};\n\nexport default webpackConfig;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB;AACrB,oBAAiC;AACjC,kBAAqB;AAGrB,mBAA4B;AAC5B,4BAA+B;AAE/B,MAAM,EAAE,QAAQ,QAAI,gCAAiB;AAAA,EACnC,SAAS;AACX,CAAC;AACD,MAAM,EAAE,WAAW,qBAAqB,4BAA4B,IAAI;AAExE,MAAM,WAAW,UACf,kBAAK,2BAA2B,EAAE;AAAA,EAChC,CAAC,KAAK,OAAO;AACX,UAAM,WAAO,0BAAY,EAAE;AAE3B,QAAI,IAAI,IAAI;AACZ,WAAO;AAAA,EACT;AAAA,EACA,CAAC;AACH;AAGK,MAAM,kBAA0C;AAAA;AAAA,EAErD,KAAK;AAAA;AAAA,EAEL,MAAM;AAAA,EACN,YAAY;AAAA;AAAA,EAGZ,UAAU;AAAA;AAAA,EAGV,oBAAoB;AAAA;AAAA,EAGpB,MAAM;AAAA,EACN,MAAM;AAAA,EAEN,YAAY;AAAA;AAAA,EAEZ,eAAe;AAAA;AAAA,IAEb,aAAa;AAAA,EACf;AAAA;AAAA,EAGA,QAAQ;AAAA,IACN,WAAW;AAAA,EACb;AACF;AAEO,MAAM,gBAAsC;AAAA;AAAA,EAEjD,MAAM;AAAA;AAAA;AAAA,EAEN,QAAQ;AAAA;AAAA,EAER,OAAO;AAAA,EACP,QAAQ;AAAA,IACN,OAAO;AAAA;AAAA,IACP,SAAS;AAAA,IACT,eAAe;AAAA,IACf,UAAU,SAAS,mBAAmB;AAAA,IACtC,MAAM;AAAA,EACR;AAAA,EAEA,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQP,gBAAgB,CAAC,GAAG;AAAA,EACpB,SAAS;AAAA;AAAA,IAEP,YAAY,CAAC,OAAO,OAAO,SAAS,SAAS,OAAO,QAAQ,QAAQ,MAAM;AAAA,IAC1E,SAAS;AAAA;AAAA,UAEP,kBAAK,WAAW,MAAM,cAAc;AAAA;AAAA,UACpC,kBAAK,QAAQ,IAAI,GAAG,cAAc;AAAA;AAAA,UAClC,kBAAK,QAAQ,IAAI,GAAG,gBAAgB,gBAAgB,cAAc;AAAA;AAAA,UAClE;AAAA,QACE,QAAQ,IAAI;AAAA,QACZ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,eAAe;AAAA;AAAA,IAEb,SAAS;AAAA;AAAA,UAEP,kBAAK,QAAQ,IAAI,GAAG,cAAc;AAAA;AAAA,UAClC,kBAAK,QAAQ,IAAI,GAAG,gBAAgB,qBAAqB,cAAc;AAAA;AAAA,UACvE;AAAA,QACE,QAAQ,IAAI;AAAA,QACZ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA;AAAA,IACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMF;AAAA,EAEA,QAAQ;AAAA,IACN,OAAO;AAAA,MACL;AAAA,QACE,MAAM;AAAA,QACN,QAAQ;AAAA,MACV;AAAA;AAAA,MAEA;AAAA;AAAA,QAEE,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,SAAS;AAAA;AAAA,UAEP,QAAQ;AAAA,QACV;AAAA,MACF;AAAA;AAAA,IAGF;AAAA,EACF;AAAA,EACA,WAAW;AAAA,EAEX,SAAS;AAAA,IACP,IAAI,qCAAe;AAAA;AAAA,EAErB;AACF;AAEA,IAAO,yBAAQ;","names":[]}

package/dist/esm/index.d.mts

@@ -0,0 +1,9 @@
+export { startServer } from "./scripts/startServer.mjs";
+export { bundle, watch } from "./scripts/bundle.mjs";
+export { IntLayerPlugin } from "./webpack-plugin.mjs";
+export {
+  devServerConfig,
+  default as webpackConfig,
+} from "./webpack.config.mjs";
+import "webpack";
+import "webpack-dev-server";

package/dist/esm/index.mjs

@@ -0,0 +1,12 @@
+import { bundle, startServer, watch } from "./scripts/index.mjs";
+import { IntLayerPlugin } from "./webpack-plugin.mjs";
+import { devServerConfig, webpackConfig } from "./webpack.config.mjs";
+export {
+  IntLayerPlugin,
+  bundle,
+  devServerConfig,
+  startServer,
+  watch,
+  webpackConfig,
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { bundle, startServer, watch } from './scripts/index';\nimport { IntLayerPlugin } from './webpack-plugin';\nimport { devServerConfig, webpackConfig } from './webpack.config';\n\nexport {\n  bundle,\n  watch,\n  startServer,\n  devServerConfig,\n  webpackConfig,\n  IntLayerPlugin,\n};\n"],"mappings":"AAAA,SAAS,QAAQ,aAAa,aAAa;AAC3C,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB,qBAAqB;","names":[]}

package/dist/esm/scripts/bundle.d.mts

@@ -0,0 +1,7 @@
+import * as webpack from "webpack";
+import { Compiler } from "webpack";
+
+declare const bundle: (compiler: Compiler) => void;
+declare const watch: (compiler: Compiler) => webpack.Watching;
+
+export { bundle, watch };

package/dist/esm/scripts/bundle.mjs

@@ -0,0 +1,35 @@
+const bundle = (compiler) =>
+  // Run the compiler
+  compiler.run((err, stats) => {
+    if (err) {
+      console.error("Webpack compilation error:", err);
+      return;
+    }
+    console.info("Webpack compilation successful.");
+    if (stats)
+      console.info(
+        stats.toString({
+          // Add options here to customize the stats output
+          colors: true,
+        })
+      );
+  });
+const watch = (compiler) =>
+  // Run the compiler
+  compiler.watch({}, (err, stats) => {
+    if (err) {
+      console.error("Webpack compilation error:", err);
+      return;
+    }
+    console.info("Webpack compilation successful.");
+    if (stats)
+      console.info(
+        stats.toString({
+          // Add options here to customize the stats output
+          colors: true,
+        })
+      );
+    console.info("Watch IntLayer content...");
+  });
+export { bundle, watch };
+//# sourceMappingURL=bundle.mjs.map

package/dist/esm/scripts/bundle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/scripts/bundle.ts"],"sourcesContent":["import type { Compiler } from 'webpack';\n\nexport const bundle = (compiler: Compiler) =>\n  // Run the compiler\n  compiler.run((err, stats) => {\n    // Handle errors and webpack compilation stats\n    if (err) {\n      console.error('Webpack compilation error:', err);\n      return;\n    }\n\n    console.info('Webpack compilation successful.');\n\n    if (stats)\n      console.info(\n        stats.toString({\n          // Add options here to customize the stats output\n          colors: true,\n        })\n      );\n  });\n\nexport const watch = (compiler: Compiler) =>\n  // Run the compiler\n  compiler.watch({}, (err, stats) => {\n    // Handle errors and webpack compilation stats\n    if (err) {\n      console.error('Webpack compilation error:', err);\n      return;\n    }\n\n    console.info('Webpack compilation successful.');\n\n    if (stats)\n      console.info(\n        stats.toString({\n          // Add options here to customize the stats output\n          colors: true,\n        })\n      );\n\n    // After successful compilation, start the server\n    console.info('Watch IntLayer content...');\n  });\n"],"mappings":"AAEO,MAAM,SAAS,CAAC;AAAA;AAAA,EAErB,SAAS,IAAI,CAAC,KAAK,UAAU;AAE3B,QAAI,KAAK;AACP,cAAQ,MAAM,8BAA8B,GAAG;AAC/C;AAAA,IACF;AAEA,YAAQ,KAAK,iCAAiC;AAE9C,QAAI;AACF,cAAQ;AAAA,QACN,MAAM,SAAS;AAAA;AAAA,UAEb,QAAQ;AAAA,QACV,CAAC;AAAA,MACH;AAAA,EACJ,CAAC;AAAA;AAEI,MAAM,QAAQ,CAAC;AAAA;AAAA,EAEpB,SAAS,MAAM,CAAC,GAAG,CAAC,KAAK,UAAU;AAEjC,QAAI,KAAK;AACP,cAAQ,MAAM,8BAA8B,GAAG;AAC/C;AAAA,IACF;AAEA,YAAQ,KAAK,iCAAiC;AAE9C,QAAI;AACF,cAAQ;AAAA,QACN,MAAM,SAAS;AAAA;AAAA,UAEb,QAAQ;AAAA,QACV,CAAC;AAAA,MACH;AAGF,YAAQ,KAAK,2BAA2B;AAAA,EAC1C,CAAC;AAAA;","names":[]}

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

@@ -0,0 +1,3 @@
+export { startServer } from "./startServer.mjs";
+export { bundle, watch } from "./bundle.mjs";
+import "webpack";

package/dist/esm/scripts/index.mjs

@@ -0,0 +1,3 @@
+export * from "./startServer.mjs";
+export * from "./bundle.mjs";
+//# sourceMappingURL=index.mjs.map

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

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

package/dist/esm/scripts/startServer.d.mts

@@ -0,0 +1,5 @@
+import { Compiler } from "webpack";
+
+declare const startServer: (compiler: Compiler) => void;
+
+export { startServer };

package/dist/esm/scripts/startServer.mjs

@@ -0,0 +1,10 @@
+import { devServerConfig } from "../webpack.config.mjs";
+const WebpackDevServer = require("webpack-dev-server");
+const startServer = (compiler) => {
+  const devServer = new WebpackDevServer(devServerConfig, compiler);
+  devServer.startCallback(() => {
+    console.info("Webpack Dev Server is running...");
+  });
+};
+export { startServer };
+//# sourceMappingURL=startServer.mjs.map

package/dist/esm/scripts/startServer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/scripts/startServer.ts"],"sourcesContent":["import type { Compiler } from 'webpack';\nimport { devServerConfig } from '../webpack.config';\n\nconst WebpackDevServer = require('webpack-dev-server');\n\nexport const startServer = (compiler: Compiler) => {\n  // Create a new instance of webpack-dev-server\n  const devServer = new WebpackDevServer(devServerConfig, compiler);\n\n  // Start the server\n  devServer.startCallback(() => {\n    console.info('Webpack Dev Server is running...');\n  });\n};\n"],"mappings":"AACA,SAAS,uBAAuB;AAEhC,MAAM,mBAAmB,QAAQ,oBAAoB;AAE9C,MAAM,cAAc,CAAC,aAAuB;AAEjD,QAAM,YAAY,IAAI,iBAAiB,iBAAiB,QAAQ;AAGhE,YAAU,cAAc,MAAM;AAC5B,YAAQ,KAAK,kCAAkC;AAAA,EACjD,CAAC;AACH;","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 };

package/dist/esm/transpiler/dictionary_to_main/createDictionaryList.mjs

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { basename, extname, relative, resolve } from "path";
+import { getConfiguration } from "@intlayer/config";
+import { sync } from "glob";
+import { getFileHash } from "../../utils.mjs";
+const { content } = getConfiguration();
+const { dictionariesDir, mainDir } = content;
+const generateDictionaryListContent = (dictionaries, format = "esm") => {
+  let content2 = "";
+  const dictionariesRef = dictionaries.map((dictionaryPath) => ({
+    relativePath: relative(mainDir, dictionaryPath),
+    id: basename(dictionaryPath, extname(dictionaryPath)),
+    // Get the base name as the dictionary id
+    hash: `_${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 (!existsSync(mainDir)) {
+    mkdirSync(mainDir, { recursive: true });
+  }
+  const dictionaries = sync(`${dictionariesDir}/**/*.json`);
+  const cjsContent = generateDictionaryListContent(dictionaries, "cjs");
+  writeFileSync(resolve(mainDir, "dictionaries.cjs"), cjsContent);
+  const esmContent = generateDictionaryListContent(dictionaries, "esm");
+  writeFileSync(resolve(mainDir, "dictionaries.mjs"), esmContent);
+};
+export { createDictionaryList };
+//# sourceMappingURL=createDictionaryList.mjs.map

package/dist/esm/transpiler/dictionary_to_main/createDictionaryList.mjs.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,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,UAAU,SAAS,UAAU,eAAe;AACrD,SAAS,wBAAwB;AACjC,SAAS,YAAY;AACrB,SAAS,mBAAmB;AAE5B,MAAM,EAAE,QAAQ,IAAI,iBAAiB;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,cAAc,SAAS,SAAS,cAAc;AAAA,IAC9C,IAAI,SAAS,gBAAgB,QAAQ,cAAc,CAAC;AAAA;AAAA,IACpD,MAAM,IAAI,YAAY,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,CAAC,WAAW,OAAO,GAAG;AACxB,cAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACxC;AAEA,QAAM,eAAyB,KAAK,GAAG,eAAe,YAAY;AAGlE,QAAM,aAAa,8BAA8B,cAAc,KAAK;AACpE,gBAAc,QAAQ,SAAS,kBAAkB,GAAG,UAAU;AAE9D,QAAM,aAAa,8BAA8B,cAAc,KAAK;AACpE,gBAAc,QAAQ,SAAS,kBAAkB,GAAG,UAAU;AAChE;","names":["content"]}

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

@@ -0,0 +1 @@
+export { createDictionaryList } from "./createDictionaryList.mjs";

package/dist/esm/transpiler/dictionary_to_main/index.mjs

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

package/dist/esm/transpiler/dictionary_to_main/index.mjs.map

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

package/dist/esm/transpiler/dictionary_to_type/createModuleAugmentation.d.mts

@@ -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/esm/transpiler/dictionary_to_type/createModuleAugmentation.mjs

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { basename, join, relative } from "path";
+import { getConfiguration } from "@intlayer/config";
+import { sync } from "glob";
+import { getFileHash, transformToCamelCase } from "../../utils.mjs";
+const { content } = getConfiguration();
+const { typesDir, moduleAugmentationDir } = content;
+const getTypeName = (id) => transformToCamelCase(`${id}Content`);
+const generateTypeIndexContent = (typeFiles) => {
+  let content2 = "import 'intlayer';\n\n";
+  const dictionariesRef = typeFiles.map((dictionaryPath) => ({
+    relativePath: relative(moduleAugmentationDir, dictionaryPath),
+    id: basename(dictionaryPath, ".d.ts"),
+    // Get the base name as the dictionary id
+    hash: `_${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");
+  content2 += `declare module 'intlayer' {
+  interface IntlayerDictionaryTypesConnector {
+${formattedDictionaryMap}
+  };
+};`;
+  return content2;
+};
+const createModuleAugmentation = () => {
+  if (!existsSync(moduleAugmentationDir)) {
+    mkdirSync(moduleAugmentationDir, { recursive: true });
+  }
+  const dictionaries = sync(`${typesDir}/**/*.d.ts`);
+  const tsContent = generateTypeIndexContent(dictionaries);
+  writeFileSync(join(moduleAugmentationDir, "intlayer.d.ts"), tsContent);
+};
+export { createModuleAugmentation, getTypeName };
+//# sourceMappingURL=createModuleAugmentation.mjs.map

package/dist/esm/transpiler/dictionary_to_type/createModuleAugmentation.mjs.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 { getConfiguration } from '@intlayer/config';\nimport { sync } from 'glob';\nimport { getFileHash, transformToCamelCase } from '../../utils';\n\nconst { content } = getConfiguration();\nconst { typesDir, moduleAugmentationDir } = content;\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 = \"import 'intlayer';\\n\\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  /**\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   * See https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation\n   */\n  content += `declare module 'intlayer' {\\n  interface IntlayerDictionaryTypesConnector {\\n${formattedDictionaryMap}\\n  };\\n};`;\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,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,UAAU,MAAM,gBAAgB;AACzC,SAAS,wBAAwB;AACjC,SAAS,YAAY;AACrB,SAAS,aAAa,4BAA4B;AAElD,MAAM,EAAE,QAAQ,IAAI,iBAAiB;AACrC,MAAM,EAAE,UAAU,sBAAsB,IAAI;AAErC,MAAM,cAAc,CAAC,OAC1B,qBAAqB,GAAG,EAAE,SAAS;AAKrC,MAAM,2BAA2B,CAAC,cAAgC;AAChE,MAAIA,WAAU;AAEd,QAAM,kBAAkB,UAAU,IAAI,CAAC,oBAAoB;AAAA,IACzD,cAAc,SAAS,uBAAuB,cAAc;AAAA,IAC5D,IAAI,SAAS,gBAAgB,OAAO;AAAA;AAAA,IACpC,MAAM,IAAI,YAAY,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,EAAAA,YAAW;AAAA;AAAA,EAAgF,sBAAsB;AAAA;AAAA;AAEjH,SAAOA;AACT;AAKO,MAAM,2BAA2B,MAAM;AAE5C,MAAI,CAAC,WAAW,qBAAqB,GAAG;AACtC,cAAU,uBAAuB,EAAE,WAAW,KAAK,CAAC;AAAA,EACtD;AAEA,QAAM,eAAyB,KAAK,GAAG,QAAQ,YAAY;AAG3D,QAAM,YAAY,yBAAyB,YAAY;AACvD,gBAAc,KAAK,uBAAuB,eAAe,GAAG,SAAS;AACvE;","names":["content"]}

package/dist/esm/transpiler/dictionary_to_type/createType.d.mts

@@ -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/esm/transpiler/dictionary_to_type/createType.mjs

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { getConfiguration } from "@intlayer/config";
+import { NodeType } from "@intlayer/core";
+import { getTypeName } from "./createModuleAugmentation.mjs";
+const { content, internationalization } = getConfiguration();
+const { typesDir } = content;
+const generateTypeScriptType = (obj) => {
+  let typeDefinition = ``;
+  const typeName = 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 === 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 === 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 (!existsSync(typesDir)) {
+    mkdirSync(typesDir, { recursive: true });
+  }
+  for (const dictionaryPath of dictionariesPaths) {
+    const contentModule = require(dictionaryPath);
+    const dictionaryName = contentModule.id;
+    const typeDefinition = generateTypeScriptType(contentModule);
+    const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);
+    writeFileSync(outputPath, typeDefinition);
+    resultTypesPaths.push(outputPath);
+  }
+  return resultTypesPaths;
+};
+export { createTypes, generateTypeScriptType, generateTypeScriptTypeContent };
+//# sourceMappingURL=createType.mjs.map

package/dist/esm/transpiler/dictionary_to_type/createType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/transpiler/dictionary_to_type/createType.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'fs';\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\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\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 keyof typeof value];\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 keyof typeof value];\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 = require(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,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,eAAe;AACxB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,OAIK;AACP,SAAS,mBAAmB;AAE5B,MAAM,EAAE,SAAS,qBAAqB,IAAI,iBAAiB;AAC3D,MAAM,EAAE,SAAS,IAAI;AAkCd,MAAM,yBAAyB,CAAC,QAA+B;AACpE,MAAI,iBAAiB;AAErB,QAAM,WAAW,YAAY,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;AAE5D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,MAAM,qBAAqB,aAAmC;AACvE,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SACJ,OAAO,MAAM,qBAAqB,aAAmC;AAEvE,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,CAAC,WAAW,QAAQ,GAAG;AACzB,cAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,aAAW,kBAAkB,mBAAmB;AAC9C,UAAM,gBAA+B,QAAQ,cAAc;AAC3D,UAAM,iBAAyB,cAAc;AAC7C,UAAM,iBAAyB,uBAAuB,aAAa;AAEnE,UAAM,aAAa,QAAQ,UAAU,GAAG,cAAc,OAAO;AAE7D,kBAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/transpiler/dictionary_to_type/index.d.mts

@@ -0,0 +1,10 @@
+export {
+  createModuleAugmentation,
+  getTypeName,
+} from "./createModuleAugmentation.mjs";
+export {
+  createTypes,
+  generateTypeScriptType,
+  generateTypeScriptTypeContent,
+} from "./createType.mjs";
+import "@intlayer/core";

package/dist/esm/transpiler/dictionary_to_type/index.mjs

@@ -0,0 +1,3 @@
+export * from "./createModuleAugmentation.mjs";
+export * from "./createType.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/esm/transpiler/dictionary_to_type/index.mjs.map

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