comment-variables 0.6.2 → 0.8.0

package/README.md

@@ -68,8 +68,6 @@ const data = {
     definitions: Object.freeze({
       exitDueToFailure:
         "Terminates the whole process with a 'failure' code (1).", // $COMMENT#JSDOC#DEFINITIONS#EXITDUETOFAILURE
-      escapeRegex:
-        'Escapes all regex characters with a `"\\"` in a string to prepare it for use in a regex.', // $COMMENT#JSDOC#DEFINITIONS#ESCAPEREGEX
       makeRuleResolve:
         "The utility that creates the resolve rule based on the flattened config data, used to transform $COMMENT#* placeholders into actual comments.", // $COMMENT#JSDOC#DEFINITIONS#MAKERULERESOLVE
       makeRuleCompress:
@@ -80,15 +78,10 @@ const data = {
         "The flow that resolves $COMMENT#* placeholders intro actual comments.", // $COMMENT#JSDOC#DEFINITIONS#RESOLVECOMMENTSFLOW
       compressCommentsFlow:
         "The flow that compresses actual comments into $COMMENT#* placeholders.", // $COMMENT#JSDOC#DEFINITIONS#COMPRESSCOMMENTSFLOW
-      flattenConfigData:
-        "Flattens the config's data property into a one-dimensional object of $COMMENT-*-like keys and string values.", // $COMMENT#JSDOC#DEFINITIONS#FLATTENCONFIGDATA
-      resolveConfig:
-        "Verifies, validates and resolves the config path to retrieve the config's data and ignores.", // $COMMENT#JSDOC#DEFINITIONS#RESOLVECONFIG
       logError:
         'Logs an error to the console depending on its type. (`"error"` or `"warning"`.)', // $COMMENT#JSDOC#DEFINITIONS#LOGERROR
     }),
     params: Object.freeze({
-      string: "The string.", // $COMMENT#JSDOC#PARAMS#STRING
       flattenedConfigData:
         "The flattened config data, with $COMMENT#* placeholders as keys and actual comments as values.", // $COMMENT#JSDOC#PARAMS#FLATTENEDCONFIGDATA
       reversedFlattenedConfigData:
@@ -99,29 +92,16 @@ const data = {
         "The array of paths and globs for the flow's ESLint instance to ignore.", // $COMMENT#JSDOC#PARAMS#IGNORES
       eitherFlattenedConfigData:
         "Either the flattened config data or the reversed flattened config data, since they share the same structure.", // $COMMENT#JSDOC#PARAMS#EITHERFLATTENEDCONFIGDATA
-      configData:
-        "The config's data property. (Values are typed `unknown` given the limitations in typing recursive values in JSDoc.)", // $COMMENT#JSDOC#PARAMS#CONFIGDATA
-      configDataMapOption:
-        "The map housing the flattened keys with their values and sources through recursion, instantiated as a `new Map()`.", // $COMMENT#JSDOC#PARAMS#CONFIGDATAMAPOPTION
-      parentKeysOption:
-        "The list of keys that are parent to the key at hand given the recursive nature of the config's data's data structure, instantiated as an empty array of strings (`[]`).", // $COMMENT#JSDOC#PARAMS#PARENTKEYSOPTION
-      configPath:
-        'The path of the config from `comments.config.js`, or from a config passed via the `--config` flag in the CLI, or from one passed via `"commentVariables.config": true` in `.vscode/settings.json` for the VS Code Extension.', // $COMMENT#JSDOC#PARAMS#CONFIGPATH
+      error: "The error object being handle for the logging.", // $COMMENT#JSDOC#PARAMS#ERROR
       options: "The additional options as follows:", // $COMMENT#JSDOC#PARAMS#OPTIONS
       settings: "The required settings as follows:", // $COMMENT#JSDOC#PARAMS#SETTINGS
-      error: "The error object being handle for the logging.", // $COMMENT#JSDOC#PARAMS#ERROR
     }),
     returns: Object.freeze({
       exitDueToFailure:
         "Never. (Somehow typing needs to be explicit for unreachable code inference.)", // $COMMENT#JSDOC#RETURNS#EXITDUETOFAILURE
-      escapeRegex: `The string with regex characters escaped.`, // $COMMENT#JSDOC#RETURNS#ESCAPEREGEX
       makeRuleResolve: "The resolve rule based on the flattened config data.", // $COMMENT#JSDOC#RETURNS#MAKERULERESOLVE
       makeRuleCompress:
         "The compress rule based on the reversed flattened config data.", // $COMMENT#JSDOC#RETURNS#MAKERULECOMPRESS
-      flattenConfigData:
-        "Both the flattened config data and its reversed version to ensure the strict reversibility of the `resolve` and `compress` commands in a success object (`success: true`). Errors are bubbled up during failures so they can be reused differently on the CLI and the VS Code Extension in a failure object (`success: false`).", // $COMMENT#JSDOC#RETURNS#FLATTENCONFIGDATA
-      resolveConfig:
-        "The flattened config data, the reverse flattened config data, the verified config path, the raw passed ignores, and the original config. Errors are returned during failures so they can be reused differently on the CLI and the VS Code Extension.", // $COMMENT#JSDOC#RETURNS#RESOLVECONFIG
     }),
   }),
 };
@@ -138,4 +118,4 @@ export default config;
 
 And yes, even comments within JavaScript and TypeScript blocks in Markdown files are addressed.
 
-_Leverage the full power of JavaScript to programmatically design your JavaScript comments._
+_Leverage the power of JavaScript to programmatically design your JavaScript comments._

package/comments.config.js

@@ -17,8 +17,6 @@ const data = {
     definitions: Object.freeze({
       exitDueToFailure:
         "Terminates the whole process with a 'failure' code (1).", // $COMMENT#JSDOC#DEFINITIONS#EXITDUETOFAILURE
-      escapeRegex:
-        'Escapes all regex characters with a `"\\"` in a string to prepare it for use in a regex.', // $COMMENT#JSDOC#DEFINITIONS#ESCAPEREGEX
       makeRuleResolve:
         "The utility that creates the resolve rule based on the flattened config data, used to transform $COMMENT#* placeholders into actual comments.", // $COMMENT#JSDOC#DEFINITIONS#MAKERULERESOLVE
       makeRuleCompress:
@@ -29,15 +27,10 @@ const data = {
         "The flow that resolves $COMMENT#* placeholders intro actual comments.", // $COMMENT#JSDOC#DEFINITIONS#RESOLVECOMMENTSFLOW
       compressCommentsFlow:
         "The flow that compresses actual comments into $COMMENT#* placeholders.", // $COMMENT#JSDOC#DEFINITIONS#COMPRESSCOMMENTSFLOW
-      flattenConfigData:
-        "Flattens the config's data property into a one-dimensional object of $COMMENT-*-like keys and string values.", // $COMMENT#JSDOC#DEFINITIONS#FLATTENCONFIGDATA
-      resolveConfig:
-        "Verifies, validates and resolves the config path to retrieve the config's data and ignores.", // $COMMENT#JSDOC#DEFINITIONS#RESOLVECONFIG
       logError:
         'Logs an error to the console depending on its type. (`"error"` or `"warning"`.)', // $COMMENT#JSDOC#DEFINITIONS#LOGERROR
     }),
     params: Object.freeze({
-      string: "The string.", // $COMMENT#JSDOC#PARAMS#STRING
       flattenedConfigData:
         "The flattened config data, with $COMMENT#* placeholders as keys and actual comments as values.", // $COMMENT#JSDOC#PARAMS#FLATTENEDCONFIGDATA
       reversedFlattenedConfigData:
@@ -48,29 +41,16 @@ const data = {
         "The array of paths and globs for the flow's ESLint instance to ignore.", // $COMMENT#JSDOC#PARAMS#IGNORES
       eitherFlattenedConfigData:
         "Either the flattened config data or the reversed flattened config data, since they share the same structure.", // $COMMENT#JSDOC#PARAMS#EITHERFLATTENEDCONFIGDATA
-      configData:
-        "The config's data property. (Values are typed `unknown` given the limitations in typing recursive values in JSDoc.)", // $COMMENT#JSDOC#PARAMS#CONFIGDATA
-      configDataMapOption:
-        "The map housing the flattened keys with their values and sources through recursion, instantiated as a `new Map()`.", // $COMMENT#JSDOC#PARAMS#CONFIGDATAMAPOPTION
-      parentKeysOption:
-        "The list of keys that are parent to the key at hand given the recursive nature of the config's data's data structure, instantiated as an empty array of strings (`[]`).", // $COMMENT#JSDOC#PARAMS#PARENTKEYSOPTION
-      configPath:
-        'The path of the config from `comments.config.js`, or from a config passed via the `--config` flag in the CLI, or from one passed via `"commentVariables.config": true` in `.vscode/settings.json` for the VS Code Extension.', // $COMMENT#JSDOC#PARAMS#CONFIGPATH
+      error: "The error object being handle for the logging.", // $COMMENT#JSDOC#PARAMS#ERROR
       options: "The additional options as follows:", // $COMMENT#JSDOC#PARAMS#OPTIONS
       settings: "The required settings as follows:", // $COMMENT#JSDOC#PARAMS#SETTINGS
-      error: "The error object being handle for the logging.", // $COMMENT#JSDOC#PARAMS#ERROR
     }),
     returns: Object.freeze({
       exitDueToFailure:
         "Never. (Somehow typing needs to be explicit for unreachable code inference.)", // $COMMENT#JSDOC#RETURNS#EXITDUETOFAILURE
-      escapeRegex: `The string with regex characters escaped.`, // $COMMENT#JSDOC#RETURNS#ESCAPEREGEX
       makeRuleResolve: "The resolve rule based on the flattened config data.", // $COMMENT#JSDOC#RETURNS#MAKERULERESOLVE
       makeRuleCompress:
         "The compress rule based on the reversed flattened config data.", // $COMMENT#JSDOC#RETURNS#MAKERULECOMPRESS
-      flattenConfigData:
-        "Both the flattened config data and its reversed version to ensure the strict reversibility of the `resolve` and `compress` commands in a success object (`success: true`). Errors are bubbled up during failures so they can be reused differently on the CLI and the VS Code Extension in a failure object (`success: false`).", // $COMMENT#JSDOC#RETURNS#FLATTENCONFIGDATA
-      resolveConfig:
-        "The flattened config data, the reverse flattened config data, the verified config path, the raw passed ignores, and the original config. Errors are returned during failures so they can be reused differently on the CLI and the VS Code Extension.", // $COMMENT#JSDOC#RETURNS#RESOLVECONFIG
     }),
   }),
 };

package/library/_commons/constants/bases.js

@@ -1,11 +1,6 @@
 import fs from "fs";
 import path from "path";
 
-import tseslint from "typescript-eslint";
-
-// plugin name
-export const commentVariablesPluginName = "comment-variables";
-
 // rule names
 export const resolveRuleName = "resolve";
 export const compressRuleName = "compress";
@@ -18,25 +13,6 @@ export const hasPackageJson = fs.existsSync(path.join(cwd, "package.json"));
 // to prevent irreversible changes
 export const hasGitFolder = fs.existsSync(path.join(cwd, ".git"));
 
-// comments.config.js // comment-variables-resolve-config
-export const defaultConfigFileName = "comments.config.js";
-
-// flags // comment-variables-resolve-config
-export const configFlag = "--config";
-export const lintConfigImportsFlag = "--lint-config-imports";
-export const myIgnoresOnlyFlag = "--my-ignores-only";
-
-// ESLint ignores
-export const knownIgnores = [
-  "node_modules",
-  "dist",
-  "out",
-  ".next",
-  ".react-router",
-  ".parcel-cache",
-  ".react-router-parcel",
-];
-
 // ESLint file globs
 export const allJSTSFileGlobs = [
   "**/*.js",
@@ -55,37 +31,3 @@ export const allMDVirtualJSTSFileGlobs = [
   "**/*.md/*.cjs",
   "**/*.md/*.mjs",
 ];
-
-// default ESLint config language options
-export const typeScriptAndJSXCompatible = {
-  // for compatibility with TypeScript (.ts and .tsx)
-  parser: tseslint.parser,
-  // for compatibility with JSX (React, etc.)
-  parserOptions: {
-    ecmaFeatures: {
-      jsx: true,
-    },
-  },
-};
-
-// messageId
-export const placeholderMessageId = "placeholderMessageId";
-
-// placeholder prefix // comment-variables-resolve-config
-export const $COMMENT = "$COMMENT";
-
-// success objects // comment-variables-resolve-config
-export const successFalse = Object.freeze({
-  success: false,
-});
-export const successTrue = Object.freeze({
-  success: true,
-});
-
-// error objects // comment-variables-resolve-config
-export const typeError = Object.freeze({
-  type: "error",
-});
-export const typeWarning = Object.freeze({
-  type: "warning",
-});

package/library/_commons/rules/compress.js

@@ -1,6 +1,8 @@
-import { placeholderMessageId, $COMMENT } from "../constants/bases.js";
-
-import { escapeRegex } from "..//utilities/helpers.js";
+import {
+  $COMMENT,
+  escapeRegex,
+  placeholderMessageId,
+} from "comment-variables-resolve-config";
 
 /**
  * The utility that creates the compress rule based on the reversed flattened config data, used to transform actual comments into $COMMENT#* placeholders.

package/library/_commons/rules/resolve.js

@@ -1,5 +1,7 @@
-import { placeholderMessageId } from "../constants/bases.js";
-import { flattenedConfigPlaceholderRegex } from "../constants/regexes.js";
+import {
+  flattenedConfigPlaceholderRegex,
+  placeholderMessageId,
+} from "comment-variables-resolve-config";
 
 /**
  * The utility that creates the resolve rule based on the flattened config data, used to transform $COMMENT#* placeholders into actual comments.

package/library/_commons/utilities/flows.js

@@ -3,12 +3,15 @@ import markdown from "@eslint/markdown";
 
 import {
   commentVariablesPluginName,
+  typeScriptAndJSXCompatible,
+} from "comment-variables-resolve-config";
+
+import {
   resolveRuleName,
   compressRuleName,
   allJSTSFileGlobs,
   allMDFileGlobs,
   allMDVirtualJSTSFileGlobs,
-  typeScriptAndJSXCompatible,
 } from "../constants/bases.js";
 import { ruleNames_makeRules } from "../constants/rules.js";
 

package/library/_commons/utilities/helpers.js

@@ -6,6 +6,8 @@
  */
 export const exitDueToFailure = () => process.exit(1);
 
+/* logError */
+
 /**
  * Logs an error to the console depending on its type. (`"error"` or `"warning"`.)
  * @param {{type: "error" | "warning"; message: string}} error The error object being handle for the logging.
@@ -23,13 +25,3 @@ export const logError = (error) => {
       break;
   }
 };
-
-/* escapeRegex */ // comment-variables-resolve-config
-
-/**
- * Escapes all regex characters with a `"\"` in a string to prepare it for use in a regex.
- * @param {string} string The string.
- * @returns The string with regex characters escaped.
- */
-export const escapeRegex = (string) =>
-  string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/library/index.js

@@ -3,22 +3,23 @@
 
 import path from "path";
 
+import resolveConfig, {
+  defaultConfigFileName,
+  configFlag,
+  lintConfigImportsFlag,
+  myIgnoresOnlyFlag,
+  knownIgnores,
+} from "comment-variables-resolve-config";
+
 import {
   cwd,
   hasPackageJson,
   hasGitFolder,
-  defaultConfigFileName, // shared
-  configFlag, // shared
-  lintConfigImportsFlag, // shared
-  myIgnoresOnlyFlag, // shared
-  knownIgnores, // shared
   resolveRuleName,
   compressRuleName,
 } from "./_commons/constants/bases.js";
 
 import { exitDueToFailure, logError } from "./_commons/utilities/helpers.js";
-import { resolveConfig } from "./_commons/utilities/resolve-config.js"; // shared
-import { findAllImports } from "find-all-js-imports"; // own package
 import {
   resolveCommentsFlow,
   compressCommentsFlow,
@@ -61,18 +62,23 @@ const passedConfigPath =
 // defaults to comments.config.js if no --config flag is set
 const rawConfigPath = passedConfigPath ?? path.join(cwd, defaultConfigFileName);
 
+console.log(`Resolving config at ${rawConfigPath}...`);
+
 const resolveConfigResults = await resolveConfig(rawConfigPath);
 if (!resolveConfigResults.success) {
   resolveConfigResults.errors.forEach((e) => logError(e));
   exitDueToFailure();
 }
 
+console.log("Config resolved.");
+
 const {
   config,
   flattenedConfigData,
   reversedFlattenedConfigData,
   configPath,
   passedIgnores,
+  rawConfigAndImportPaths,
 } = resolveConfigResults;
 
 skipDetails || console.log("Running with config:", config);
@@ -88,21 +94,9 @@ skipDetails || console.log("Passed ignores are:", passedIgnores);
 // ADDRESSES THE --lint-config-imports FLAG, GIVEN THAT THE FILES IMPORTED BY THE CONFIG ARE IGNORED BY DEFAULT.
 
 const lintConfigImports = commands.indexOf(lintConfigImportsFlag) >= 2;
-let rawConfigPathIgnores = [configPath];
-
-if (!lintConfigImports) {
-  const findAllImportsResults = findAllImports(configPath);
-  if (!findAllImportsResults.success) {
-    findAllImportsResults.errors.forEach((e) => logError(e));
-    console.warn(
-      "Defaulting to --lint-config-imports flag behavior, not ignoring config path imports, only the config path itself."
-    );
-  } else {
-    rawConfigPathIgnores = [...findAllImportsResults.visitedSet] ?? [
-      configPath,
-    ];
-  }
-}
+const rawConfigPathIgnores = lintConfigImports
+  ? [configPath]
+  : rawConfigAndImportPaths;
 
 // the ignore paths must be relative
 const configPathIgnores = rawConfigPathIgnores.map((e) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comment-variables",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "A CLI tool for configuring, managing and maintaining JavaScript comments as JavaScript variables.",
   "bin": {
     "jscomments": "./library/index.js",
@@ -26,10 +26,8 @@
   "type": "module",
   "dependencies": {
     "@eslint/markdown": "^6.5.0",
+    "comment-variables-resolve-config": "^1.3.0",
     "eslint": "^9.29.0",
-    "find-all-js-imports": "^1.0.0",
-    "tsconfig-paths": "^4.2.0",
-    "typescript-eslint": "^8.34.1",
     "zod": "^3.25.67"
   },
   "devDependencies": {

package/library/_commons/constants/regexes.js

@@ -1,13 +0,0 @@
-import { $COMMENT } from "./bases.js";
-
-import { escapeRegex } from "../utilities/helpers.js";
-
-// comment-variables-resolve-config
-export const configKeyRegex = /^[\p{Ll}\p{Lu}\p{Lo}\p{Pd}\p{Pc}\p{N}\s]+$/u;
-// comment-variables-resolve-config
-export const flattenedConfigKeyRegex = /^[\p{Lu}\p{Lo}\p{Pd}\p{Pc}\p{N}#]+$/u; // same as configKeyRegex but without lowercase letters (\p{Ll}), without whitespaces (\s which are replaced by underscores) and with the '#' character (that links each subkey together)
-// comment-variables-resolve-config
-export const flattenedConfigPlaceholderRegex = new RegExp(
-  `${escapeRegex($COMMENT)}#([\\p{Lu}\\p{Lo}\\p{Pd}\\p{Pc}\\p{N}#_]+)`,
-  "gu"
-); // same as flattenedConfigKeyRegex but taking the prefix $COMMENT and its # into consideration, removing ^ and $ in the capture group, and using _ as replacement for whitesplaces, globally

package/library/_commons/schemas/config.js

@@ -1,67 +0,0 @@
-import { z } from "zod";
-
-import { configKeyRegex } from "../constants/regexes.js";
-
-export const ConfigDataSchema = z
-  .lazy(() =>
-    z.record(
-      z.unknown().superRefine((val, ctx) => {
-        if (typeof val === "string") {
-          return;
-        }
-
-        if (typeof val === "object" && val && !Array.isArray(val)) {
-          const parsed = ConfigDataSchema.safeParse(val);
-          if (!parsed.success) {
-            for (const issue of parsed.error.issues) {
-              ctx.addIssue({
-                ...issue,
-                path: [...ctx.path, ...issue.path],
-              });
-            }
-          }
-          return;
-        }
-
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Value \`${val}\` of type "${typeof val}" should be a string or a nested object.`,
-          path: ctx.path,
-        });
-      })
-    )
-  )
-  .superRefine((obj, ctx) => {
-    for (const key of Object.keys(obj)) {
-      if (key.includes("$")) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Key "${key}" should not include the "$" character.`,
-          path: [key],
-        });
-      }
-      if (key.includes("#")) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Key "${key}" should not include the "#" character.`,
-          path: [key],
-        });
-      }
-      if (!configKeyRegex.test(key)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Key "${key}" should only include whitespaces (s), lowercase letters (Ll), uppercase letters (Lu), other letters (Lo), numbers (N), dash punctuation (Pd), and connector punctuation (Pc).`,
-          path: [key],
-        });
-      }
-    }
-  });
-
-export const ConfigIgnoresSchema = z.array(
-  z.string({
-    message: `The config's "ignores" key array should be made of string or be empty.`,
-  }),
-  {
-    message: `The config's "ignores" key value should be an array of strings (or at the very least an empty array).`,
-  }
-);

package/library/_commons/utilities/flatten-config-data.js

@@ -1,145 +0,0 @@
-import { successFalse, successTrue, typeError } from "../constants/bases.js";
-import { flattenedConfigKeyRegex } from "../constants/regexes.js";
-
-/**
- * @typedef {Record<string, unknown>} ConfigData
- *
- * @typedef {{
- *   success: false;
- *   errors: Array<{ type: "error" | "warning"; message: string }>;
- * } | {
- *   success: true;
- *   flattenedConfigData: Record<string, string>;
- *   reversedFlattenedConfigData: Record<string, string>;
- * }} FlattenConfigDataResults
- */
-
-/**
- * Flattens the config's data property into a one-dimensional object of $COMMENT-*-like keys and string values.
- * @param {ConfigData} configData The config's data property. (Values are typed `unknown` given the limitations in typing recursive values in JSDoc.)
- * @param {Object} [options] The additional options as follows:
- * @param {Map<string, {value: string; source: string}>} [options.configDataMap] The map housing the flattened keys with their values and sources through recursion, instantiated as a `new Map()`.
- * @param {string[]} [options.parentKeys] The list of keys that are parent to the key at hand given the recursive nature of the config's data's data structure, instantiated as an empty array of strings (`[]`).
- * @returns Both the flattened config data and its reversed version to ensure the strict reversibility of the `resolve` and `compress` commands in a success object (`success: true`). Errors are bubbled up during failures so they can be reused differently on the CLI and the VS Code Extension in a failure object (`success: false`).
- */
-export const flattenConfigData = (
-  configData,
-  { configDataMap = new Map(), parentKeys = [] } = {}
-) => {
-  for (const [key, value] of Object.entries(configData)) {
-    const newKeys = [...parentKeys, key];
-    const normalizedKey = newKeys
-      .map((k) => k.toUpperCase())
-      .join("#")
-      .replace(/\s/g, "_");
-    const source = newKeys.join(" > ");
-
-    if (typeof value === "string") {
-      if (configDataMap.has(normalizedKey)) {
-        // checks the uniqueness of each normalized key
-        return {
-          ...successFalse,
-          errors: [
-            {
-              ...typeError,
-              message: `ERROR. The normalized key "${normalizedKey}" has already been assigned. Check between the two following key paths: \n"${
-                configDataMap.get(normalizedKey).source
-              }" \n"${source}"`,
-            },
-          ],
-        };
-      }
-
-      configDataMap.set(normalizedKey, {
-        value,
-        source,
-      });
-    } else if (typeof value === "object" && value && !Array.isArray(value)) {
-      const subConfigData = /** @type {ConfigData} */ (value);
-      const flattenConfigDataOptions = { configDataMap, parentKeys: newKeys };
-
-      const flattenConfigDataResults = /** @type {FlattenConfigDataResults} */ (
-        flattenConfigData(subConfigData, flattenConfigDataOptions)
-      );
-      if (!flattenConfigDataResults.success) return flattenConfigDataResults;
-    }
-  }
-
-  // At this point we're out of the recursion, and we can start working with the complete data.
-
-  // strips metadata
-  /**@type {Map<string, string>} */
-  const map = new Map();
-  configDataMap.forEach((value, key) => {
-    map.set(key, value.value);
-  });
-
-  // makes the flattened config data object
-  const flattenedConfigData = Object.fromEntries(map);
-
-  // The integrity of the flattened config data needs to be established before working with it safely.
-
-  const flattenedConfigDataKeysSet = new Set(Object.keys(flattenedConfigData));
-
-  const flattenedConfigDataValuesArray = Object.values(flattenedConfigData);
-  const flattenedConfigDataValuesSet = new Set(flattenedConfigDataValuesArray);
-
-  for (const key of flattenedConfigDataKeysSet) {
-    if (flattenedConfigDataValuesSet.has(key)) {
-      // checks the reversability of flattenedConfigData
-      return {
-        ...successFalse,
-        errors: [
-          {
-            ...typeError,
-            message: `ERROR. The key "${key}" is and shouldn't be among the values of flattenedConfigData.`,
-          },
-        ],
-      };
-    }
-    if (!flattenedConfigKeyRegex.test(key)) {
-      // checks if each key for flattenedConfigData passes the flattenedConfigKeyRegex test
-      return {
-        ...successFalse,
-        errors: [
-          {
-            ...typeError,
-            message: `ERROR. Somehow the key "${key}" is not properly formatted. (This is mostly an internal mistake.)`,
-          },
-        ],
-      };
-    }
-  }
-
-  /** @type {Set<string>} */
-  const set = new Set();
-
-  for (const value of flattenedConfigDataValuesArray) {
-    if (set.has(value)) {
-      console.log("errors, duplicate value");
-      // checks that no two values are duplicate
-      return {
-        ...successFalse,
-        errors: [
-          {
-            ...typeError,
-            message: `ERROR. The value "${value}" is already assigned to an existing key.`,
-          },
-        ],
-      };
-    }
-    set.add(value);
-  }
-
-  // Also including the reversed flattened config data.
-
-  const reversedFlattenedConfigData = Object.fromEntries(
-    Object.entries(flattenedConfigData).map(([key, value]) => [value, key])
-  );
-
-  return {
-    ...successTrue,
-    flattenedConfigData,
-    reversedFlattenedConfigData,
-  };
-};

package/library/_commons/utilities/resolve-config.js

@@ -1,110 +0,0 @@
-import fs from "fs";
-import url from "url";
-
-import { successFalse, typeError } from "../constants/bases.js";
-
-import { flattenConfigData } from "./flatten-config-data.js";
-
-import { ConfigDataSchema, ConfigIgnoresSchema } from "../schemas/config.js";
-
-/**
- * Verifies, validates and resolves the config path to retrieve the config's data and ignores.
- * @param {string} configPath The path of the config from `comments.config.js`, or from a config passed via the `--config` flag in the CLI, or from one passed via `"commentVariables.config": true` in `.vscode/settings.json` for the VS Code Extension.
- * @returns The flattened config data, the reverse flattened config data, the verified config path, the raw passed ignores, and the original config. Errors are returned during failures so they can be reused differently on the CLI and the VS Code Extension.
- */
-export async function resolveConfig(configPath) {
-  // Step 1: Checks if config file exists
-
-  if (!fs.existsSync(configPath)) {
-    return {
-      ...successFalse,
-      errors: [
-        {
-          ...typeError,
-          message: "ERROR. No config file found.",
-        },
-      ],
-    };
-  }
-
-  // Step 2: Imports the config dynamically
-
-  const configModule = /** @type {unknown} */ (
-    await import(url.pathToFileURL(configPath))
-  );
-  const config = /** @type {unknown} */ (configModule.default);
-
-  // Step 3: Validates config object
-
-  // validates config
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    return {
-      ...successFalse,
-      errors: [
-        {
-          ...typeError,
-          message:
-            "ERROR. Invalid config format. The config should be an object.",
-        },
-      ],
-    };
-  }
-
-  // validates config.data
-  const configDataResult = ConfigDataSchema.safeParse(config.data);
-
-  if (!configDataResult.success) {
-    return {
-      ...successFalse,
-      errors: [
-        {
-          ...typeError,
-          message: "ERROR. Config data could not pass validation from zod.",
-        },
-        ...configDataResult.error.errors.map((e) => ({
-          ...typeError,
-          message: e.message,
-        })),
-      ],
-    };
-  }
-
-  // validates config.ignores
-  const configIgnoresSchemaResult = ConfigIgnoresSchema.safeParse(
-    config.ignores
-  );
-
-  if (!configIgnoresSchemaResult.success) {
-    return {
-      ...successFalse,
-      errors: [
-        {
-          ...typeError,
-          message: "ERROR. Config ignores could not pass validation from zod.",
-        },
-        ...configIgnoresSchemaResult.error.errors.map((e) => ({
-          ...typeError,
-          message: e.message,
-        })),
-      ],
-    };
-  }
-
-  const flattenedConfigDataResults = flattenConfigData(configDataResult.data);
-
-  if (!flattenedConfigDataResults.success) {
-    return flattenedConfigDataResults;
-  }
-
-  // sends back:
-  // - the flattened config data,
-  // - the reverse flattened config data,
-  // - the verified config path
-  // - and the raw passed ignores
-  return {
-    ...flattenedConfigDataResults, // finalized
-    configPath, // finalized
-    passedIgnores: configIgnoresSchemaResult.data, // addressed with --lint-config-imports and --my-ignores-only to be finalized
-    config, // and the config itself too
-  };
-}