@intlayer/chokidar 2.0.0 → 2.0.1

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

@@ -6,17 +6,17 @@ import {
   NodeType
 } from "@intlayer/core";
 import { getTypeName } from './createModuleAugmentation.mjs';
-const { content, internationalization } = getConfiguration();
+const { content } = getConfiguration();
 const { typesDir } = content;
 const isESModule = typeof import.meta.url === "string";
 const requireFunction = isESModule ? createRequire(import.meta.url) : require;
+const getFirstValue = (obj) => Object.values(obj)[0];
 const generateTypeScriptType = (obj) => {
   let typeDefinition = ``;
   const typeName = getTypeName(obj.id);
-  typeDefinition += `export type ${typeName} = {
-`;
+  typeDefinition += `export type ${typeName} = `;
   typeDefinition += generateTypeScriptTypeContent(obj);
-  typeDefinition += "};\n\n";
+  typeDefinition += ";\n\n";
   return typeDefinition;
 };
 const isReactNode = (node) => typeof node?.key !== "undefined" && typeof node?.props !== "undefined";
@@ -28,54 +28,40 @@ const generateTypeScriptTypeContent = (obj) => {
   if (isReactNodeValue) {
     return `JSX.Element`;
   }
-  let typeDefinition = ``;
+  if (
+    // Check if the value is a typed node
+    obj.nodeType === NodeType.Translation
+  ) {
+    const { nodeType, ...content2 } = obj;
+    const languageValue = getFirstValue(
+      content2
+    );
+    const tsType = generateTypeScriptTypeContent(languageValue);
+    return `${tsType}`;
+  } else if (
+    // Check if the value is a typed node
+    obj.nodeType === NodeType.Enumeration
+  ) {
+    const { nodeType, ...content2 } = obj;
+    const quantifiedValue = getFirstValue(
+      content2
+    );
+    const tsType = generateTypeScriptTypeContent(quantifiedValue);
+    return `(quantity: number) => ${tsType}`;
+  } else if (Array.isArray(obj)) {
+    const arrayType = generateTypeScriptTypeContent(obj[0]);
+    return `${arrayType}[]`;
+  }
+  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 = generateTypeScriptTypeContent(
-        value?.[internationalization.defaultLocale]
-      );
-      typeDefinition += `  ${key}: ${tsType},
-`;
-    } else if (
-      // Check if the value is a typed node
-      typeof value === "object" && nodeType === NodeType.Enumeration
-    ) {
-      const tsType = generateTypeScriptTypeContent(
-        value?.[internationalization.defaultLocale]
-      );
-      typeDefinition += `  ${key}: (quantity: number) => ${tsType},
-`;
-    } else if (
-      // Check if the value is a nested object
-      typeof value === "object"
-    ) {
-      const isArray = Array.isArray(value);
-      if (isArray) {
-        const arrayType = generateTypeScriptTypeContent(value);
-        typeDefinition += `  ${key}: ${arrayType}[],
-`;
-      } else {
-        const nestedType = generateTypeScriptTypeContent(value);
-        typeDefinition += `  ${key}: {${nestedType}},
-`;
-      }
-    } 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},
-`;
+    const isLast = Object.keys(obj).indexOf(key) === Object.keys(obj).length - 1;
+    const nestedType = generateTypeScriptTypeContent(value);
+    typeDefinition += `'${key}': ${nestedType}`;
+    if (!isLast) {
+      typeDefinition += ",";
     }
   }
+  typeDefinition += "}";
   return typeDefinition;
 };
 const createTypes = (dictionariesPaths) => {
@@ -84,9 +70,9 @@ const createTypes = (dictionariesPaths) => {
     mkdirSync(typesDir, { recursive: true });
   }
   for (const dictionaryPath of dictionariesPaths) {
-    const contentModule = requireFunction(dictionaryPath);
-    const dictionaryName = contentModule.id;
-    const typeDefinition = generateTypeScriptType(contentModule);
+    const dictionary = requireFunction(dictionaryPath);
+    const dictionaryName = dictionary.id;
+    const typeDefinition = generateTypeScriptType(dictionary);
     const outputPath = resolve(typesDir, `${dictionaryName}.d.ts`);
     writeFileSync(outputPath, typeDefinition);
     resultTypesPaths.push(outputPath);

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

@@ -1 +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\nconst isReactNode = (node: Record<string, unknown>): boolean =>\n  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';\n\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport const generateTypeScriptTypeContent = (obj: Content): string => {\n  if (typeof obj !== 'object' || obj === null) {\n    return `${typeof obj}`;\n  }\n\n  const isReactNodeValue = isReactNode(obj as Record<string, unknown>);\n\n  if (isReactNodeValue) {\n    // ReactNode handling\n    return `JSX.Element`;\n  }\n\n  let typeDefinition = ``;\n  for (const [key, value] of Object.entries(obj)) {\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 = generateTypeScriptTypeContent(\n        value?.[internationalization.defaultLocale as ValueKey]\n      );\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 = generateTypeScriptTypeContent(\n        value?.[internationalization.defaultLocale as ValueKey] as Content\n      );\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    ) {\n      const isArray = Array.isArray(value);\n\n      if (isArray) {\n        // Array handling (simplified, assumes non-empty arrays with uniform type)\n        const arrayType = generateTypeScriptTypeContent(value as Content);\n\n        typeDefinition += `  ${key}: ${arrayType}[],\\n`;\n      } else {\n        // Nested object, recurse\n        const nestedType = generateTypeScriptTypeContent(value as Content);\n\n        typeDefinition += `  ${key}: {${nestedType}},\\n`;\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,SAAS,YAAY,WAAW,qBAAqB;AACrD,SAAS,qBAAqB;AAC9B,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;AAErB,MAAM,aAAa,OAAO,YAAY,QAAQ;AAC9C,MAAM,kBAAkB,aAAa,cAAc,YAAY,GAAG,IAAI;AAkC/D,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;AAEA,MAAM,cAAc,CAAC,SACnB,OAAO,MAAM,QAAQ,eAAe,OAAO,MAAM,UAAU;AAGtD,MAAM,gCAAgC,CAAC,QAAyB;AACrE,MAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,WAAO,GAAG,OAAO,GAAG;AAAA,EACtB;AAEA,QAAM,mBAAmB,YAAY,GAA8B;AAEnE,MAAI,kBAAkB;AAEpB,WAAO;AAAA,EACT;AAEA,MAAI,iBAAiB;AACrB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,UAAM,WAAkC,OAAqB;AAG7D;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SAAS;AAAA,QACb,QAAQ,qBAAqB,aAAyB;AAAA,MACxD;AACA,wBAAkB,KAAK,GAAG,KAAK,MAAM;AAAA;AAAA,IACvC;AAAA;AAAA,MAEE,OAAO,UAAU,YACjB,aAAa,SAAS;AAAA,MACtB;AACA,YAAM,SAAS;AAAA,QACb,QAAQ,qBAAqB,aAAyB;AAAA,MACxD;AAEA,wBAAkB,KAAK,GAAG,2BAA2B,MAAM;AAAA;AAAA,IAC7D;AAAA;AAAA,MAEE,OAAO,UAAU;AAAA,MACjB;AACA,YAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAI,SAAS;AAEX,cAAM,YAAY,8BAA8B,KAAgB;AAEhE,0BAAkB,KAAK,GAAG,KAAK,SAAS;AAAA;AAAA,MAC1C,OAAO;AAEL,cAAM,aAAa,8BAA8B,KAAgB;AAEjE,0BAAkB,KAAK,GAAG,MAAM,UAAU;AAAA;AAAA,MAC5C;AAAA,IACF;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,gBAAgB,cAAc;AACnE,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":[]}
+{"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 Dictionary,\n  type DictionaryValue,\n  type TypedNode,\n} from '@intlayer/core';\nimport { getTypeName } from './createModuleAugmentation';\n\nconst { content } = getConfiguration();\nconst { typesDir } = content;\n\nconst isESModule = typeof import.meta.url === 'string';\nconst requireFunction = isESModule ? createRequire(import.meta.url) : require;\n\nconst getFirstValue = (obj: Record<string, DictionaryValue>): DictionaryValue =>\n  Object.values(obj)[0];\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: Dictionary): string => {\n  let typeDefinition = ``;\n\n  const typeName = getTypeName(obj.id);\n\n  typeDefinition += `export type ${typeName} = `;\n  typeDefinition += generateTypeScriptTypeContent(obj as DictionaryValue);\n  typeDefinition += ';\\n\\n';\n\n  return typeDefinition;\n};\n\nconst isReactNode = (node: Record<string, unknown>): boolean =>\n  typeof node?.key !== 'undefined' && typeof node?.props !== 'undefined';\n\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport const generateTypeScriptTypeContent = (obj: DictionaryValue): string => {\n  if (typeof obj !== 'object' || obj === null) {\n    return `${typeof obj}`;\n  }\n\n  const isReactNodeValue = isReactNode(obj as Record<string, unknown>);\n\n  if (isReactNodeValue) {\n    // ReactNode handling\n    return `JSX.Element`;\n  }\n\n  if (\n    // Check if the value is a typed node\n    (obj as TypedNode).nodeType === NodeType.Translation\n  ) {\n    const { nodeType, ...content } = obj as TypedNode;\n\n    const languageValue: DictionaryValue = getFirstValue(\n      content as Record<string, DictionaryValue>\n    );\n\n    const tsType = generateTypeScriptTypeContent(languageValue);\n    return `${tsType}`;\n  } else if (\n    // Check if the value is a typed node\n    (obj as TypedNode).nodeType === NodeType.Enumeration\n  ) {\n    const { nodeType, ...content } = obj as TypedNode;\n\n    const quantifiedValue: DictionaryValue = getFirstValue(\n      content as Record<string, DictionaryValue>\n    );\n\n    const tsType = generateTypeScriptTypeContent(quantifiedValue);\n\n    return `(quantity: number) => ${tsType}`;\n  } else if (Array.isArray(obj)) {\n    // Array handling (simplified, assumes non-empty arrays with uniform type)\n    const arrayType = generateTypeScriptTypeContent(obj[0] as DictionaryValue);\n\n    return `${arrayType}[]`;\n  }\n\n  let typeDefinition = '{';\n  // Nested object, recurse\n  for (const [key, value] of Object.entries(obj)) {\n    const isLast =\n      Object.keys(obj).indexOf(key) === Object.keys(obj).length - 1;\n\n    const nestedType = generateTypeScriptTypeContent(value as DictionaryValue);\n\n    typeDefinition += `'${key}': ${nestedType}`;\n\n    if (!isLast) {\n      typeDefinition += ',';\n    }\n  }\n  typeDefinition += '}';\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 dictionary: Dictionary = requireFunction(dictionaryPath);\n    const dictionaryName: string = dictionary.id;\n    const typeDefinition: string = generateTypeScriptType(dictionary);\n\n    const outputPath: string = 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,qBAAqB;AAC9B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,OAIK;AACP,SAAS,mBAAmB;AAE5B,MAAM,EAAE,QAAQ,IAAI,iBAAiB;AACrC,MAAM,EAAE,SAAS,IAAI;AAErB,MAAM,aAAa,OAAO,YAAY,QAAQ;AAC9C,MAAM,kBAAkB,aAAa,cAAc,YAAY,GAAG,IAAI;AAEtE,MAAM,gBAAgB,CAAC,QACrB,OAAO,OAAO,GAAG,EAAE,CAAC;AAkCf,MAAM,yBAAyB,CAAC,QAA4B;AACjE,MAAI,iBAAiB;AAErB,QAAM,WAAW,YAAY,IAAI,EAAE;AAEnC,oBAAkB,eAAe,QAAQ;AACzC,oBAAkB,8BAA8B,GAAsB;AACtE,oBAAkB;AAElB,SAAO;AACT;AAEA,MAAM,cAAc,CAAC,SACnB,OAAO,MAAM,QAAQ,eAAe,OAAO,MAAM,UAAU;AAGtD,MAAM,gCAAgC,CAAC,QAAiC;AAC7E,MAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,WAAO,GAAG,OAAO,GAAG;AAAA,EACtB;AAEA,QAAM,mBAAmB,YAAY,GAA8B;AAEnE,MAAI,kBAAkB;AAEpB,WAAO;AAAA,EACT;AAEA;AAAA;AAAA,IAEG,IAAkB,aAAa,SAAS;AAAA,IACzC;AACA,UAAM,EAAE,UAAU,GAAGA,SAAQ,IAAI;AAEjC,UAAM,gBAAiC;AAAA,MACrCA;AAAA,IACF;AAEA,UAAM,SAAS,8BAA8B,aAAa;AAC1D,WAAO,GAAG,MAAM;AAAA,EAClB;AAAA;AAAA,IAEG,IAAkB,aAAa,SAAS;AAAA,IACzC;AACA,UAAM,EAAE,UAAU,GAAGA,SAAQ,IAAI;AAEjC,UAAM,kBAAmC;AAAA,MACvCA;AAAA,IACF;AAEA,UAAM,SAAS,8BAA8B,eAAe;AAE5D,WAAO,yBAAyB,MAAM;AAAA,EACxC,WAAW,MAAM,QAAQ,GAAG,GAAG;AAE7B,UAAM,YAAY,8BAA8B,IAAI,CAAC,CAAoB;AAEzE,WAAO,GAAG,SAAS;AAAA,EACrB;AAEA,MAAI,iBAAiB;AAErB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,UAAM,SACJ,OAAO,KAAK,GAAG,EAAE,QAAQ,GAAG,MAAM,OAAO,KAAK,GAAG,EAAE,SAAS;AAE9D,UAAM,aAAa,8BAA8B,KAAwB;AAEzE,sBAAkB,IAAI,GAAG,MAAM,UAAU;AAEzC,QAAI,CAAC,QAAQ;AACX,wBAAkB;AAAA,IACpB;AAAA,EACF;AACA,oBAAkB;AAClB,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,aAAyB,gBAAgB,cAAc;AAC7D,UAAM,iBAAyB,WAAW;AAC1C,UAAM,iBAAyB,uBAAuB,UAAU;AAEhE,UAAM,aAAqB,QAAQ,UAAU,GAAG,cAAc,OAAO;AAErE,kBAAc,YAAY,cAAc;AAExC,qBAAiB,KAAK,UAAU;AAAA,EAClC;AAEA,SAAO;AACT;","names":["content"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/chokidar",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "private": false,
   "description": "Chokidar application for IntLayer - Transpile IntLayer declaration files into dictionaries.",
   "keywords": [
@@ -41,8 +41,6 @@
   },
   "files": [
     "./dist",
-    "./src",
-    "./bin",
     "./package.json"
   ],
   "dependencies": {
@@ -53,9 +51,9 @@
     "glob": "^10.3.12",
     "node-loader": "^2.0.0",
     "rimraf": "5.0.5",
-    "@intlayer/config": "^2.0.0",
-    "@intlayer/core": "^2.0.0",
-    "intlayer": "^2.0.0"
+    "@intlayer/config": "^2.0.1",
+    "@intlayer/core": "^2.0.1",
+    "intlayer": "^2.0.1"
   },
   "devDependencies": {
     "@changesets/cli": "2.27.1",

package/src/chokidar/index.ts

@@ -1 +0,0 @@
-export * from './watcher';

package/src/chokidar/watcher.ts

@@ -1,75 +0,0 @@
-import { relative } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import chokidar, { type WatchOptions } from 'chokidar';
-import { sync } from 'glob';
-import { buildDictionary } from '../transpiler/declaration_file_to_dictionary/index';
-import { createDictionaryList } from '../transpiler/dictionary_to_main/createDictionaryList';
-import {
-  createTypes,
-  createModuleAugmentation,
-} from '../transpiler/dictionary_to_type/index';
-
-// Initialize chokidar watcher (non-persistent)
-export const watch = (options?: WatchOptions) => {
-  const { content } = getConfiguration({
-    verbose: true,
-  });
-
-  const { watchedFilesPatternWithPath, baseDir } = content;
-
-  const files: string[] = sync(watchedFilesPatternWithPath);
-
-  return chokidar
-    .watch(watchedFilesPatternWithPath, {
-      persistent: true, // Make the watcher persistent
-      ignoreInitial: true, // Process existing files
-      ...options,
-    })
-    .on('ready', async () => {
-      const dictionariesPaths = await buildDictionary(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) => {
-      // Process the file with the functionToRun
-      console.info('Removed file detected: ', relative(baseDir, filePath));
-    })
-    .on('add', async (filePath) => {
-      // Process the file with the functionToRun
-      console.info('Additional file detected: ', relative(baseDir, filePath));
-      const dictionaries = await buildDictionary(filePath);
-
-      console.info('Building TypeScript types...');
-      createTypes(dictionaries);
-
-      console.info('Building type index...');
-      createModuleAugmentation();
-
-      console.info('Building main...');
-      createDictionaryList();
-    })
-    .on('change', async (filePath) => {
-      // Process the file with the functionToRun
-      console.info('Change detected: ', relative(baseDir, filePath));
-      const dictionaries = await buildDictionary(filePath);
-
-      console.info('Building TypeScript types...');
-      createTypes(dictionaries);
-    })
-    .on('error', (error) => {
-      console.error('Watcher error:', error);
-    });
-};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/buildI18nDictionary.ts

@@ -1,95 +0,0 @@
-import { mkdir, writeFile } from 'fs/promises';
-import { resolve } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import type { ContentModule } from '@intlayer/core';
-import {
-  processContentDeclaration,
-  extractObjectsWithId,
-} from '../intlayer_dictionary/index';
-import {
-  type I18nDictionariesOutput,
-  createI18nDictionaries,
-} from './convertContentDeclarationInto18nDictionaries';
-
-const { content } = getConfiguration();
-const { i18nDictionariesDir } = content;
-
-type DictionariesDeclaration = Record<string, I18nDictionariesOutput>;
-
-/**
- * This function writes the dictionaries to the file system
- */
-const writeDictionary = async (
-  dictionariesDeclaration: DictionariesDeclaration
-) => {
-  const resultDictionariesPaths: string[] = [];
-
-  for (const [nameSpace, localContent] of Object.entries(
-    dictionariesDeclaration
-  )) {
-    for await (const [locale, content] of Object.entries(localContent)) {
-      const contentString = JSON.stringify(content);
-
-      const outputFileName = `${nameSpace}.json`;
-      const resultDirPath = resolve(i18nDictionariesDir, locale);
-      const resultFilePath = resolve(resultDirPath, outputFileName);
-
-      // Create the dictionaries folder if it doesn't exist
-      await mkdir(resultDirPath, { recursive: true });
-
-      // Create the json file
-      await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {
-        console.error(`Error creating ${outputFileName}:`, err);
-      });
-
-      resultDictionariesPaths.push(resultFilePath);
-    }
-  }
-
-  return resultDictionariesPaths;
-};
-
-/**
- * This function transpile content declaration to i18n dictionaries
- */
-export const buildI18nDictionary = async (
-  contentDeclarationsPaths: string[] | string
-) => {
-  const resultDictionariesPaths: string[] = [];
-
-  if (typeof contentDeclarationsPaths === 'string') {
-    contentDeclarationsPaths = [contentDeclarationsPaths];
-  }
-
-  for await (const contentDeclarationPath of contentDeclarationsPaths) {
-    const result = await processContentDeclaration(contentDeclarationPath);
-
-    if (!result) {
-      continue;
-    }
-
-    const nestedContent: ContentModule[] = extractObjectsWithId(result);
-
-    // Create dictionaries for each nested content and format them
-    const dictionariesDeclaration: DictionariesDeclaration =
-      nestedContent.reduce((acc, content) => {
-        const id = content.id;
-        const i18Content = createI18nDictionaries(content);
-
-        return {
-          ...acc,
-          [id]: i18Content,
-        };
-      }, {});
-
-    // Write the dictionaries to the file system
-    const dictionariesPaths: string[] = await writeDictionary(
-      dictionariesDeclaration
-    );
-
-    // Add the paths to the result
-    resultDictionariesPaths.push(...dictionariesPaths);
-  }
-
-  return resultDictionariesPaths;
-};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/convertContentDeclarationInto18nDictionaries.ts

@@ -1,91 +0,0 @@
-import { getConfiguration, type Locales } from '@intlayer/config';
-import {
-  NodeType,
-  type TranslationContent,
-  type Content,
-  type TypedNode,
-  type EnumerationContent,
-} from '@intlayer/core';
-import { convertPluralsValues } from './convertPluralsValues';
-
-type Dictionary = Record<string, unknown>;
-export type I18nDictionariesOutput = Partial<Record<Locales, Dictionary>>;
-
-const {
-  internationalization: { locales },
-} = getConfiguration();
-
-const isReactNode = (node: Record<string, unknown>): boolean =>
-  typeof node?.key !== 'undefined' &&
-  typeof node?.props !== 'undefined' &&
-  typeof node?.type !== 'undefined';
-
-// Build dictionary for a specific locale
-const buildDictionary = (content: Dictionary, locale: Locales): unknown => {
-  if (
-    // Translation node
-    content &&
-    (content as TypedNode).nodeType === NodeType.Translation
-  ) {
-    const result = (content as TranslationContent<unknown>)[locale];
-
-    return buildDictionary(result as Dictionary, locale);
-  } else if (
-    // Translation node
-    content &&
-    (content as TypedNode).nodeType === NodeType.Enumeration
-  ) {
-    const plurals: Record<string, unknown> = {};
-
-    Object.keys(content).forEach((quantity) => {
-      const letterNumber = convertPluralsValues(quantity);
-
-      const value = (content as EnumerationContent<unknown>)[
-        quantity as keyof EnumerationContent<unknown>
-      ];
-
-      plurals[`${letterNumber}_${letterNumber}`] = buildDictionary(
-        value as Dictionary,
-        locale
-      );
-    });
-
-    return plurals;
-  } else if (
-    // React element node
-    isReactNode(content as Record<string, unknown>)
-  ) {
-    return JSON.stringify(content);
-  } else if (
-    // Nested object
-    typeof content === 'object'
-  ) {
-    const result: Record<string, unknown> = {};
-
-    Object.keys(content).forEach((dictionaryValue) => {
-      result[dictionaryValue] = buildDictionary(
-        content[dictionaryValue] as Dictionary,
-        locale
-      );
-    });
-
-    return result;
-  }
-
-  return content;
-};
-
-export const createI18nDictionaries = (
-  content: Content
-): I18nDictionariesOutput => {
-  // Map dictionaries for each locale
-  const result: I18nDictionariesOutput = locales.reduce(
-    (acc, locale) => ({
-      ...acc,
-      [locale]: buildDictionary(content, locale),
-    }),
-    {}
-  );
-
-  return result;
-};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/convertPluralsValues.ts

@@ -1,22 +0,0 @@
-export const convertPluralsValues = (number: string): string => {
-  switch (number) {
-    case '1':
-      return 'one';
-    case '2':
-      return 'two';
-    case '3':
-      return 'three';
-    case '4':
-      return 'four';
-    case '5':
-      return 'five';
-    case '6':
-      return 'six';
-    case '7':
-      return 'seven';
-    case '8':
-      return 'eight';
-    default:
-      return number.toString();
-  }
-};

package/src/transpiler/declaration_file_to_dictionary/i18n_dictionary/index.ts

@@ -1 +0,0 @@
-export * from './buildI18nDictionary';

package/src/transpiler/declaration_file_to_dictionary/index.ts

@@ -1,21 +0,0 @@
-import { getConfiguration } from '@intlayer/config';
-import { buildI18nDictionary } from './i18n_dictionary/index';
-import { buildIntlayerDictionary } from './intlayer_dictionary/index';
-
-const {
-  content: { dictionaryOutput },
-} = getConfiguration();
-
-export const buildDictionary = async (
-  contentDeclarationsPaths: string | string[]
-): Promise<string[]> => {
-  if (dictionaryOutput.includes('i18next')) {
-    return await buildI18nDictionary(contentDeclarationsPaths);
-  }
-
-  if (dictionaryOutput.includes('intlayer')) {
-    return await buildIntlayerDictionary(contentDeclarationsPaths);
-  }
-
-  return [];
-};

package/src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/buildIntlayerDictionary.ts

@@ -1,70 +0,0 @@
-import { mkdir, writeFile } from 'fs/promises';
-import { resolve } from 'path';
-import { getConfiguration } from '@intlayer/config';
-import type { ContentModule } from '@intlayer/core';
-import { extractObjectsWithId } from './extractNestedJSON';
-import { processContentDeclaration } from './processContentDeclaration';
-
-const { content } = getConfiguration();
-const { dictionariesDir } = content;
-
-const writeDictionary = async (dictionaries: ContentModule[]) => {
-  const resultDictionariesPaths: string[] = [];
-
-  for await (const content of dictionaries) {
-    const contentString = JSON.stringify(content);
-
-    const id = content.id;
-    const outputFileName = `${id}.json`;
-    const resultFilePath = resolve(dictionariesDir, outputFileName);
-
-    // Create the json file
-    await writeFile(resultFilePath, contentString, 'utf8').catch((err) => {
-      console.error(`Error creating ${outputFileName}:`, err);
-    });
-
-    resultDictionariesPaths.push(resultFilePath);
-  }
-
-  return resultDictionariesPaths;
-};
-
-/**
- * This function transpile the bundled code to to make dictionaries as JSON files
- */
-export const buildIntlayerDictionary = async (
-  contentDeclarationsPaths: string[] | string
-) => {
-  const resultDictionariesPaths: string[] = [];
-
-  if (typeof contentDeclarationsPaths === 'string') {
-    contentDeclarationsPaths = [contentDeclarationsPaths];
-  }
-
-  // Create the dictionaries folder if it doesn't exist
-  await mkdir(resolve(dictionariesDir), { recursive: true });
-
-  for await (const contentDeclarationPath of contentDeclarationsPaths) {
-    const result = await processContentDeclaration(contentDeclarationPath);
-
-    if (!result) {
-      continue;
-    }
-
-    const nestedContent: ContentModule[] = extractObjectsWithId(result);
-
-    const contentWithFilePath: ContentModule[] = nestedContent.map(
-      (content) => ({
-        ...content,
-        filePath: contentDeclarationPath,
-      })
-    );
-
-    const dictionariesPaths: string[] =
-      await writeDictionary(contentWithFilePath);
-
-    resultDictionariesPaths.push(...dictionariesPaths);
-  }
-
-  return resultDictionariesPaths;
-};

package/src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/extractNestedJSON.ts

@@ -1,60 +0,0 @@
-import type { Content, 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'
- * }]
- *
- */
-export const extractObjectsWithId = (input: ContentModule): ContentModule[] => {
-  // Function to recursively search and extract nested objects with an 'id'
-  const search = (obj: Content, results: ContentModule[]): void => {
-    if (obj && typeof obj === 'object') {
-      if (Object.hasOwn(obj, 'id')) {
-        results.push(obj as ContentModule);
-      }
-      for (const key of Object.keys(obj)) {
-        if (typeof obj[key] === 'object') {
-          search(obj[key] as Content, results);
-        }
-      }
-    }
-  };
-
-  const results: ContentModule[] = [];
-  search(input, results);
-  return results;
-};

package/src/transpiler/declaration_file_to_dictionary/intlayer_dictionary/index.ts

@@ -1,3 +0,0 @@
-export * from './extractNestedJSON';
-export * from './processContentDeclaration';
-export * from './buildIntlayerDictionary';