definition-generator-framework 1.6.3 → 1.6.4

package/package.json

@@ -1,56 +1,58 @@
-{
-  "name": "definition-generator-framework",
-  "version": "1.6.3",
-  "description": "Definition Generator Framework",
-  "main": "src/index.ts",
-  "publishConfig": {
-    "main": "dist/index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sefabaser/definition-generator-framework.git"
-  },
-  "author": "sefabaser",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/sefabaser/definition-generator-framework/issues"
-  },
-  "prettier": {
-    "trailingComma": "none",
-    "tabWidth": 2,
-    "printWidth": 130,
-    "singleQuote": true,
-    "arrowParens": "avoid"
-  },
-  "homepage": "https://github.com/sefabaser/definition-generator-framework#readme",
-  "scripts": {
-    "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm install",
-    "pretest": "cls",
-    "test": "vitest",
-    "start": "npm run build && node dist",
-    "build": "tsc",
-    "lint": "eslint \"src/**/*.ts\" --fix",
-    "deploy": "vitest run && npm run build && npm publish"
-  },
-  "dependencies": {
-    "helpers-lib": "1.5.32",
-    "image-size": "1.1.1",
-    "joi": "17.11.0",
-    "prettier": "3.1.1"
-  },
-  "devDependencies": {
-    "@types/glob": "8.1.0",
-    "@types/node": "20.10.5",
-    "@types/rimraf": "4.0.5",
-    "@typescript-eslint/eslint-plugin": "6.16.0",
-    "@typescript-eslint/parser": "6.16.0",
-    "eslint": "8.56.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-no-null": "1.0.2",
-    "eslint-plugin-sort-class-members": "1.19.0",
-    "ts-node": "10.9.2",
-    "typescript": "5.3.3",
-    "vitest": "1.6.0"
-  }
-}
+{
+  "name": "definition-generator-framework",
+  "version": "1.6.4",
+  "description": "Definition Generator Framework",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "main": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sefabaser/definition-generator-framework.git"
+  },
+  "author": "sefabaser",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sefabaser/definition-generator-framework/issues"
+  },
+  "prettier": {
+    "trailingComma": "none",
+    "tabWidth": 2,
+    "printWidth": 130,
+    "singleQuote": true,
+    "arrowParens": "avoid"
+  },
+  "homepage": "https://github.com/sefabaser/definition-generator-framework#readme",
+  "scripts": {
+    "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm install",
+    "pretest": "cls",
+    "test": "vitest",
+    "start": "npm run build && node dist",
+    "build": "tsc",
+    "lint": "eslint \"src/**/*.ts\" --fix",
+    "deploy": "vitest run && npm run build && npm publish",
+    "prepack": "cp package.json package.json.bak && ts-node scripts/prepare-package-json.ts",
+    "postpack": "mv package.json.bak package.json"
+  },
+  "dependencies": {
+    "helpers-lib": "1.5.32",
+    "image-size": "1.1.1",
+    "joi": "17.11.0",
+    "prettier": "3.1.1"
+  },
+  "devDependencies": {
+    "@types/glob": "8.1.0",
+    "@types/node": "20.10.5",
+    "@types/rimraf": "4.0.5",
+    "@typescript-eslint/eslint-plugin": "6.16.0",
+    "@typescript-eslint/parser": "6.16.0",
+    "eslint": "8.56.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-no-null": "1.0.2",
+    "eslint-plugin-sort-class-members": "1.19.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.3.3",
+    "vitest": "1.6.0"
+  }
+}

package/package.json.bak

@@ -0,0 +1,58 @@
+{
+  "name": "definition-generator-framework",
+  "version": "1.6.4",
+  "description": "Definition Generator Framework",
+  "main": "src/index.ts",
+  "publishConfig": {
+    "main": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sefabaser/definition-generator-framework.git"
+  },
+  "author": "sefabaser",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sefabaser/definition-generator-framework/issues"
+  },
+  "prettier": {
+    "trailingComma": "none",
+    "tabWidth": 2,
+    "printWidth": 130,
+    "singleQuote": true,
+    "arrowParens": "avoid"
+  },
+  "homepage": "https://github.com/sefabaser/definition-generator-framework#readme",
+  "scripts": {
+    "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm install",
+    "pretest": "cls",
+    "test": "vitest",
+    "start": "npm run build && node dist",
+    "build": "tsc",
+    "lint": "eslint \"src/**/*.ts\" --fix",
+    "deploy": "vitest run && npm run build && npm publish",
+    "prepack": "cp package.json package.json.bak && ts-node scripts/prepare-package-json.ts",
+    "postpack": "mv package.json.bak package.json"
+  },
+  "dependencies": {
+    "helpers-lib": "1.5.32",
+    "image-size": "1.1.1",
+    "joi": "17.11.0",
+    "prettier": "3.1.1"
+  },
+  "devDependencies": {
+    "@types/glob": "8.1.0",
+    "@types/node": "20.10.5",
+    "@types/rimraf": "4.0.5",
+    "@typescript-eslint/eslint-plugin": "6.16.0",
+    "@typescript-eslint/parser": "6.16.0",
+    "eslint": "8.56.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-no-null": "1.0.2",
+    "eslint-plugin-sort-class-members": "1.19.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.3.3",
+    "vitest": "1.6.0"
+  }
+}

package/scripts/prepare-package-json.ts

@@ -0,0 +1,23 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+let fs = require('fs');
+
+let cwd = process.cwd();
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+let packageJson = require(`${cwd}/package.json`);
+
+let newPackageJson = {
+  ...packageJson,
+  main: packageJson.publishConfig?.main ?? packageJson.main
+};
+
+if (packageJson.publishConfig?.types) {
+  newPackageJson.types = packageJson.publishConfig.types;
+}
+
+if (packageJson.publishConfig?.module) {
+  newPackageJson.module = packageJson.publishConfig.module;
+}
+
+try {
+  fs.writeFileSync(`${cwd}/package.json`, JSON.stringify(newPackageJson, undefined, 2));
+} catch (e) {}

package/src/_mocks/mocks.ts

@@ -1,43 +0,0 @@
-import { Context } from '../framework/context';
-import { FileInfo, LocationInFile } from '../framework/interfaces';
-
-export function resetContext(): void {
-  Context.compilerExecutionPath = 'D:/test';
-  Context.outputPath = 'D:/test/.asset-build';
-  Context.config.projectRoot = 'D:/';
-  Context.files = [];
-  Context.rawDefinitions = [];
-  Context.errorLogs = [];
-  Context.output = [];
-}
-
-export function setMockContextFromContents(contents: string[]): void {
-  resetContext();
-  let fileIndex = 0;
-  contents.forEach(content => {
-    fileIndex++;
-    Context.files.push({ path: `D:/test/file-${fileIndex}.md`, content });
-  });
-}
-
-export function getMockFileInfo(content: string): FileInfo {
-  return {
-    content,
-    path: 'D:/test/sample.md'
-  };
-}
-
-export const SampleLocation1: LocationInFile = {
-  line: 2,
-  path: 'D:/test/file-1.md'
-};
-
-export const SampleLocation2: LocationInFile = {
-  line: 2,
-  path: 'D:/test/file-2.md'
-};
-
-export const SampleLocation3: LocationInFile = {
-  line: 2,
-  path: 'D:/test/file-3.md'
-};

package/src/decorators/definition-component.ts

@@ -1,39 +0,0 @@
-import Joi from 'joi';
-
-import { Output } from '../framework/interfaces';
-
-export type DefinitionComponentClassType<T> = new (...args: any[]) => DefinitionComponent<T> | SingleDefinitionComponent<T>;
-
-export interface DefinitionComponentMeta {
-  componentName: string;
-  keyName?: string;
-  singleton?: boolean;
-  validationSchema: Joi.Schema;
-}
-
-export function DefinitionComponentDecorator(meta: DefinitionComponentMeta) {
-  return function (ComponentClass: DefinitionComponentClassType<any>): any {
-    (<any>ComponentClass).$meta = {
-      componentName: meta.componentName,
-      keyName: meta.keyName,
-      singleton: meta.singleton,
-      validationSchema: meta.validationSchema
-    };
-  };
-}
-
-export abstract class DefinitionComponent<T> {
-  static getSchema(): Joi.Schema {
-    return (<any>this).$meta.validationSchema;
-  }
-
-  abstract process(definitions: T[], context: Output): Promise<void>;
-}
-
-export abstract class SingleDefinitionComponent<T> {
-  static getSchema(): Joi.Schema {
-    return (<any>this).$meta.validationSchema;
-  }
-
-  abstract process(definitions: T, context: Output): Promise<void>;
-}

package/src/decorators/definition-generator.ts

@@ -1,23 +0,0 @@
-import { DefinitionComponentClassType } from './definition-component';
-import { Kernel } from '../framework/kernel';
-
-interface DefinitionGeneratorMeta {
-  modules: DefinitionComponentClassType<any>[];
-  interfaces: string;
-}
-
-let ModuleIsRegistered = false;
-export function DefinitionGeneratorDecorator(meta: DefinitionGeneratorMeta) {
-  return function (ModuleClass: DefinitionGeneratorClassType): any {
-    if (ModuleIsRegistered) {
-      console.error('There can be only one definition module!');
-    } else {
-      ModuleIsRegistered = true;
-      Kernel.process(meta.modules, meta.interfaces);
-    }
-  };
-}
-
-export type DefinitionGeneratorClassType = new (...args: any[]) => DefinitionGenerator;
-
-export abstract class DefinitionGenerator {}

package/src/framework/context.ts

@@ -1,13 +0,0 @@
-import { Config, ErrorLog, FileInfo, RawDefinition } from './interfaces';
-
-export class Context {
-  static compilerExecutionPath: string = '';
-  static outputPath: string = '';
-  static config: Config = {
-    projectRoot: ''
-  };
-  static rawDefinitions: RawDefinition[] = [];
-  static files: FileInfo[] = [];
-  static output: FileInfo[] = [];
-  static errorLogs: ErrorLog[] = [];
-}

package/src/framework/definition-store.ts

@@ -1,68 +0,0 @@
-import { JsonHelper } from 'helpers-lib';
-
-import { DefinitionComponentClassType } from '../decorators/definition-component';
-import { RawDefinition } from './interfaces';
-
-export class DefinitionStore {
-  private static rawDefinitionsMap: Map<string, Map<string, RawDefinition>> = new Map<string, Map<string, RawDefinition>>();
-  private static definitionsMap: Map<string, Map<string, any>> = new Map<string, any>();
-
-  static getDefinition<T>(definitionClass: DefinitionComponentClassType<T>, key: string): T | undefined {
-    if (!(<any>definitionClass).$meta.keyName) {
-      throw new Error(`"${definitionClass.name}" doesn't have a keyName, getDefinition cannot be called on it.`);
-    }
-    return this.definitionsMap.get(this.getComponentName(definitionClass))?.get(key);
-  }
-
-  static getDefinitionOrFail<T>(definitionClass: DefinitionComponentClassType<T>, key: string): T {
-    let definition = this.getDefinition(definitionClass, key);
-    if (!definition) {
-      throw new Error(`No result found for "${key}" in "${definitionClass.name}".`);
-    }
-    return definition;
-  }
-
-  private static isValidComponentName(componentName: string): boolean {
-    return this.definitionsMap.has(componentName);
-  }
-
-  private static setComponentNames(componentNames: string[]): void {
-    componentNames.forEach(componentName => {
-      this.definitionsMap.set(componentName, new Map<string, any>());
-    });
-  }
-
-  private static setDefinition<T>(definitionClass: DefinitionComponentClassType<T>, key: string, definition: T): void {
-    let classMap = this.definitionsMap.get(this.getComponentName(definitionClass));
-    if (classMap) {
-      classMap.set(key, JsonHelper.deepCopy(definition));
-    }
-  }
-
-  private static isRawDefinitionExists<T>(definitionClass: DefinitionComponentClassType<T>, key: string): boolean {
-    return this.rawDefinitionsMap.get(definitionClass.name)?.has(key) ? true : false;
-  }
-
-  private static getRawDefinition<T>(definitionClass: DefinitionComponentClassType<T>, key: string): RawDefinition | undefined {
-    return this.rawDefinitionsMap.get(definitionClass.name)?.get(key);
-  }
-
-  private static setRawDefinition<T>(
-    definitionClass: DefinitionComponentClassType<T>,
-    key: string,
-    definition: RawDefinition
-  ): void {
-    if (!this.rawDefinitionsMap.has(definitionClass.name)) {
-      this.rawDefinitionsMap.set(definitionClass.name, new Map<string, RawDefinition>());
-    }
-
-    let classMap = this.rawDefinitionsMap.get(definitionClass.name);
-    if (classMap) {
-      classMap.set(key, JsonHelper.deepCopy(definition));
-    }
-  }
-
-  private static getComponentName<T>(definitionClass: DefinitionComponentClassType<T>): string {
-    return (<any>definitionClass).$meta.componentName;
-  }
-}

package/src/framework/interfaces.ts

@@ -1,42 +0,0 @@
-export interface FileSystem {
-  existsSync: (path: string) => boolean;
-}
-
-export interface FileInfo {
-  path: string;
-  content: string;
-}
-
-// UTIL
-export interface LocationInFile {
-  readonly path: string;
-  readonly line: number;
-}
-
-export interface ErrorLog {
-  readonly description: string;
-  readonly location: LocationInFile;
-}
-
-export interface Config {
-  projectRoot: string;
-}
-
-// RAW-DEFINITIONS
-export type RawData = undefined | string | ParsedStructure[] | Record<string, ParsedStructure>;
-
-export interface ParsedStructure {
-  readonly rawData: RawData;
-  readonly line: number;
-}
-
-export interface RawDefinition {
-  readonly componentName: string;
-  readonly parsedStructure: ParsedStructure;
-  readonly location: LocationInFile;
-}
-
-export interface Output {
-  addFile: (fileInfo: FileInfo) => void;
-  addError: (errorLog: ErrorLog) => void;
-}

package/src/framework/kernel.ts

@@ -1,167 +0,0 @@
-import * as fs from 'fs';
-import * as glob from 'glob';
-import * as path from 'path';
-import * as rimraf from 'rimraf';
-import { Comparator } from 'helpers-lib';
-
-import { ErrorLog, FileInfo, Output } from './interfaces';
-import { RawDataParser } from '../pipeline/raw-data-parser';
-import { Validator } from '../helpers/validator/validator';
-import { CustomValidatorHelper } from '../helpers/validator/custom-validator-helper/custom-validator.helper';
-import { DefinitionStore } from './definition-store';
-import { DefinitionComponentClassType, DefinitionComponentMeta } from '../decorators/definition-component';
-import { Context } from './context';
-
-export const ConfigDefinitionComponentName = 'CONFIG';
-const KeyValueRegex = /^[a-z]+([a-zA-Z0-9]+)*$/;
-
-export class Kernel {
-  static async process(modules: DefinitionComponentClassType<any>[], interfaces: string): Promise<void> {
-    DefinitionStore['setComponentNames']([
-      ConfigDefinitionComponentName,
-      ...modules.map(module => (<any>module).$meta.componentName)
-    ]);
-
-    Context.compilerExecutionPath = path.resolve('./').replace(/\\/g, '/');
-    Context.outputPath = `${Context.compilerExecutionPath}/.asset-build`;
-    Context.files = glob.sync(`${Context.compilerExecutionPath}/**/*.md`).map(filePath => {
-      let content = fs.readFileSync(filePath).toString();
-      let fileInfo: FileInfo = { path: filePath, content };
-      return fileInfo;
-    });
-
-    let outputFiles = await this.generateOutputFiles(modules, interfaces);
-    rimraf.sync(Context.outputPath); // Remove the output folder if it exists
-    outputFiles.forEach(outputFile => {
-      let fullPath = Context.outputPath + outputFile.path;
-      let folderPath = fullPath.substring(0, fullPath.lastIndexOf('/'));
-      fs.mkdirSync(folderPath, { recursive: true });
-      fs.writeFileSync(fullPath, outputFile.content);
-    });
-  }
-
-  private static async generateOutputFiles(
-    modules: DefinitionComponentClassType<any>[],
-    interfaces: string
-  ): Promise<FileInfo[]> {
-    Context.output.push({
-      path: '/index.ts',
-      content: interfaces
-    });
-
-    RawDataParser.process();
-    let preparedItems = modules.map(ModuleClass => {
-      let meta: DefinitionComponentMeta = (<any>ModuleClass).$meta;
-
-      let output: Output = {
-        addFile: (fileInfo: FileInfo) => {
-          Context.output.push(fileInfo);
-        },
-        addError: (errorLog: ErrorLog) => {
-          Context.errorLogs.push(errorLog);
-        }
-      };
-
-      this.iterateOnKeyNames(meta.keyName, meta.componentName, ModuleClass);
-
-      let definitions: any[];
-      if (meta.singleton) {
-        definitions = Validator.validateAndConvertSingular<any>(meta.componentName, meta.validationSchema) || [];
-      } else {
-        definitions = Validator.validateAndConvert<any>(meta.componentName, meta.validationSchema);
-      }
-
-      this.registerDefinitions(definitions, meta.keyName, ModuleClass);
-
-      return {
-        definitions,
-        output,
-        ModuleClass
-      };
-    });
-
-    for (let preparedItem of preparedItems) {
-      if (preparedItem.definitions) {
-        let module = new preparedItem.ModuleClass();
-        await module.process(preparedItem.definitions, preparedItem.output);
-      }
-    }
-
-    CustomValidatorHelper.logDuplicates();
-    return this.getOutputFiles();
-  }
-
-  private static iterateOnKeyNames(
-    keyName: string | undefined,
-    componentName: string,
-    ModuleClass: DefinitionComponentClassType<any>
-  ): void {
-    let rawDefinitions = Validator.getRawDefinitions(componentName);
-    if (keyName) {
-      rawDefinitions.forEach(rawDefinition => {
-        let rootRawData = rawDefinition.parsedStructure.rawData;
-        if (!Comparator.isObject(rootRawData) || Comparator.isArray(rootRawData)) {
-          Context.errorLogs.push({
-            description: `KeyName shold not be used with a content which is not an object, keyName: "${keyName}" in "${componentName}"`,
-            location: { line: rawDefinition.parsedStructure.line, path: rawDefinition.location.path }
-          });
-        } else {
-          let keyValue = rootRawData[keyName]?.rawData;
-          if (!Comparator.isString(keyValue)) {
-            // Do nothing, joi validation will log the errors
-          } else if (KeyValueRegex.test(keyValue) === false) {
-            Context.errorLogs.push({
-              description: `KeyName should be a valid key, keyName: "${keyName}" in "${componentName}"`,
-              location: { line: rootRawData[keyName].line, path: rawDefinition.location.path }
-            });
-          } else if (DefinitionStore['isRawDefinitionExists'](ModuleClass, keyValue)) {
-            Context.errorLogs.push({
-              description: `Definition with key "${keyValue}" already exists in "${componentName}"`,
-              location: { line: rootRawData[keyName].line, path: rawDefinition.location.path }
-            });
-          } else {
-            DefinitionStore['setRawDefinition'](ModuleClass, keyValue, rawDefinition);
-          }
-        }
-      });
-    }
-  }
-
-  private static registerDefinitions(
-    definitions: any[],
-    keyName: string | undefined,
-    ModuleClass: DefinitionComponentClassType<any>
-  ): void {
-    if (keyName) {
-      definitions.forEach((definition: any) => {
-        let definitionName: string = definition[keyName];
-        DefinitionStore['setDefinition'](ModuleClass, definitionName, definition);
-      });
-    }
-  }
-
-  private static getOutputFiles(): FileInfo[] {
-    if (Context.errorLogs.length === 0) {
-      console.dir('Definition generation completed without errors.');
-      return Context.output;
-    } else {
-      console.dir(
-        Context.errorLogs.map(log => ({
-          description: log.description,
-          location: `${log.location.path}:${log.location.line}`
-        })),
-        { depth: undefined }
-      );
-      return [
-        {
-          path: '/error-logs.md',
-          content: Context.errorLogs
-            .map(
-              errorLog => `${errorLog.description}\r\nPath: '${errorLog.location.path}', Line: '${errorLog.location.line}'\r\n`
-            )
-            .join('\r\n')
-        }
-      ];
-    }
-  }
-}

package/src/helpers/common-functions/common-functions.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { CommonFunctions } from './common-functions';
-
-describe('COMMON FUNCTIONS', () => {
-  test('kabab case to camel case', () => {
-    expect(CommonFunctions.kebabCaseToCamelCase('')).toEqual('');
-    expect(CommonFunctions.kebabCaseToCamelCase('text')).toEqual('text');
-    expect(CommonFunctions.kebabCaseToCamelCase('TEXT')).toEqual('text');
-    expect(CommonFunctions.kebabCaseToCamelCase('text-asdf')).toEqual('textAsdf');
-    expect(CommonFunctions.kebabCaseToCamelCase('TEXT-ASDF')).toEqual('textAsdf');
-  });
-
-  test('lower case first letter', () => {
-    expect(CommonFunctions.lowerCaseFirstLetter('')).toEqual('');
-    expect(CommonFunctions.lowerCaseFirstLetter('text')).toEqual('text');
-    expect(CommonFunctions.lowerCaseFirstLetter(' ')).toEqual(' ');
-    expect(CommonFunctions.lowerCaseFirstLetter('Text')).toEqual('text');
-    expect(CommonFunctions.lowerCaseFirstLetter(' Text')).toEqual(' Text');
-  });
-
-  test('upper case first letter', () => {
-    expect(CommonFunctions.upperCaseFirstLetter('')).toEqual('');
-    expect(CommonFunctions.upperCaseFirstLetter('Text')).toEqual('Text');
-    expect(CommonFunctions.upperCaseFirstLetter(' ')).toEqual(' ');
-    expect(CommonFunctions.upperCaseFirstLetter('text')).toEqual('Text');
-    expect(CommonFunctions.upperCaseFirstLetter(' text')).toEqual(' text');
-  });
-
-  test('remove whitespace', () => {
-    expect(CommonFunctions.removeWhiteSpace('')).toEqual('');
-    expect(CommonFunctions.removeWhiteSpace('text')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('  text')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text  ')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text\n')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text\r')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text\r\n')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text//')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text //')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text // asdf')).toEqual('text');
-    expect(CommonFunctions.removeWhiteSpace('text text')).toEqual('text text');
-    expect(CommonFunctions.removeWhiteSpace('text    text')).toEqual('text text');
-  });
-
-  test('remove comments', () => {
-    expect(CommonFunctions.removeComments('')).toEqual('');
-    expect(CommonFunctions.removeComments('text')).toEqual('text');
-    expect(CommonFunctions.removeComments('  text  ')).toEqual('  text');
-    expect(CommonFunctions.removeComments('  text//')).toEqual('  text');
-    expect(CommonFunctions.removeComments('  text //')).toEqual('  text');
-    expect(CommonFunctions.removeComments('  text // asdf')).toEqual('  text');
-    expect(CommonFunctions.removeComments('- Symbol: □             // Dirt\n')).toEqual('- Symbol: □');
-  });
-});