definition-generator-framework 1.12.4 → 1.12.6

package/dist/helpers/output-helper/output-helper.d.ts

@@ -1,30 +1,30 @@
 declare class OutputHelperClass {
-    generateArrayOutput(options: {
-        preText?: string;
-        variableName: string;
-        variableType: string;
-        variable: any[];
-        filePath?: string;
-        assetUrl?: string;
-        replaceMap?: {
-            target: string;
-            replace: string;
-        }[];
-    }): Promise<string>;
-    generateOutput(options: {
-        preText?: string;
-        variableName: string;
-        variableType?: string;
-        variable: any;
-        replaceMap?: {
-            target: string;
-            replace: string;
-        }[];
-    }): Promise<string>;
-    private convertToRelativePath;
-    private replaceOutput;
-    private format;
-    private stringify;
+  generateArrayOutput(options: {
+    preText?: string;
+    variableName: string;
+    variableType: string;
+    variable: any[];
+    filePath?: string;
+    assetUrl?: string;
+    replaceMap?: {
+      target: string;
+      replace: string;
+    }[];
+  }): Promise<string>;
+  generateOutput(options: {
+    preText?: string;
+    variableName: string;
+    variableType?: string;
+    variable: any;
+    replaceMap?: {
+      target: string;
+      replace: string;
+    }[];
+  }): Promise<string>;
+  private convertToRelativePath;
+  private replaceOutput;
+  private format;
+  private stringify;
 }
 export declare const OutputHelper: OutputHelperClass;
 export {};

package/dist/helpers/output-helper/output-helper.js

@@ -1,123 +1,143 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null)
+      for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.OutputHelper = void 0;
-const prettier = __importStar(require("prettier"));
-const path_1 = __importDefault(require("path"));
-const context_1 = require("../../framework/context");
-const helpers_lib_1 = require("helpers-lib");
+const prettier = __importStar(require('prettier'));
+const path_1 = __importDefault(require('path'));
+const context_1 = require('../../framework/context');
+const helpers_lib_1 = require('helpers-lib');
 class OutputHelperClass {
-    async generateArrayOutput(options) {
-        let output = '';
-        if (options.preText) {
-            output += `${options.preText}\n\n`;
-        }
-        let assetsReplaceMap;
-        if (options.assetUrl) {
-            if (!options.filePath) {
-                throw new Error('filePath is required when using assetUrl');
-            }
-            let urls = options.variable.map(item => {
-                let url = helpers_lib_1.JsonHelper.deepFind(item, options.assetUrl);
-                if (!url) {
-                    throw new Error(`OutputHelperClass: Asset url is not found in the given variable! item: "${JSON.stringify(item)}", assetUrl: "${options.assetUrl}"`);
-                }
-                return url;
-            });
-            let assetUrlToNameMap = new Map();
-            urls.forEach(url => {
-                if (!assetUrlToNameMap.has(url)) {
-                    let name = `asset${assetUrlToNameMap.size}`;
-                    assetUrlToNameMap.set(url, name);
-                }
-            });
-            let imports = Array.from(assetUrlToNameMap, ([key, value]) => ({ name: value, url: key }))
-                .map(item => `import ${item.name} from '${this.convertToRelativePath(options.filePath, item.url)}';`)
-                .join('\n');
-            output += imports + '\n\n';
-            assetsReplaceMap = urls.reduce((map, url) => [...map, { target: `"${url}"`, replace: assetUrlToNameMap.get(url) }], []);
-        }
-        if (options.variable.reduce) {
-            let content = options.variable.reduce((acc, item, index) => `${acc}${index !== 0 ? ',' : ''}${this.stringify(item)}`, '');
-            output += `export const ${options.variableName}: ${options.variableType} = [${content}];`;
-        }
-        else {
-            console.error(`Given variable is not an array, do you mean to use "generateOutput()", for the variable "${options.variableName}"?`);
-        }
-        if (assetsReplaceMap) {
-            output = this.replaceOutput(output, assetsReplaceMap);
-        }
-        if (options.replaceMap) {
-            output = this.replaceOutput(output, options.replaceMap);
-        }
-        return this.format(output);
+  async generateArrayOutput(options) {
+    let output = '';
+    if (options.preText) {
+      output += `${options.preText}\n\n`;
     }
-    async generateOutput(options) {
-        let output = '';
-        if (options.preText) {
-            output += `${options.preText}\n\n`;
-        }
-        if (options.variableType) {
-            output += `export const ${options.variableName}: ${options.variableType} = ${this.stringify(options.variable)}`;
+    let assetsReplaceMap;
+    if (options.assetUrl) {
+      if (!options.filePath) {
+        throw new Error('filePath is required when using assetUrl');
+      }
+      let urls = options.variable.map(item => {
+        let url = helpers_lib_1.JsonHelper.deepFind(item, options.assetUrl);
+        if (!url) {
+          throw new Error(
+            `OutputHelperClass: Asset url is not found in the given variable! item: "${JSON.stringify(item)}", assetUrl: "${options.assetUrl}"`
+          );
         }
-        else {
-            output += `export const ${options.variableName} = ${this.stringify(options.variable)}`;
+        return url;
+      });
+      let assetUrlToNameMap = new Map();
+      urls.forEach(url => {
+        if (!assetUrlToNameMap.has(url)) {
+          let name = `asset${assetUrlToNameMap.size}`;
+          assetUrlToNameMap.set(url, name);
         }
-        if (options.replaceMap) {
-            output = this.replaceOutput(output, options.replaceMap);
-        }
-        return this.format(output);
+      });
+      let imports = Array.from(assetUrlToNameMap, ([key, value]) => ({ name: value, url: key }))
+        .map(item => `import ${item.name} from '${this.convertToRelativePath(options.filePath, item.url)}';`)
+        .join('\n');
+      output += imports + '\n\n';
+      assetsReplaceMap = urls.reduce((map, url) => [...map, { target: `"${url}"`, replace: assetUrlToNameMap.get(url) }], []);
+    }
+    if (options.variable.reduce) {
+      let content = options.variable.reduce((acc, item, index) => `${acc}${index !== 0 ? ',' : ''}${this.stringify(item)}`, '');
+      output += `export const ${options.variableName}: ${options.variableType} = [${content}];`;
+    } else {
+      console.error(
+        `Given variable is not an array, do you mean to use "generateOutput()", for the variable "${options.variableName}"?`
+      );
+    }
+    if (assetsReplaceMap) {
+      output = this.replaceOutput(output, assetsReplaceMap);
     }
-    convertToRelativePath(filePath, relativePathFromRoot) {
-        let fromPath = context_1.Context.outputPath + filePath.substring(0, filePath.lastIndexOf('/'));
-        let toPath = context_1.Context.config.projectRoot + relativePathFromRoot.substring(1);
-        return path_1.default.relative(fromPath, toPath).replace(/\\/g, '/');
+    if (options.replaceMap) {
+      output = this.replaceOutput(output, options.replaceMap);
     }
-    replaceOutput(output, replaceMap) {
-        replaceMap.forEach(item => {
-            output = output.replace(new RegExp(item.target, 'g'), item.replace);
-        });
-        return output;
+    return this.format(output);
+  }
+  async generateOutput(options) {
+    let output = '';
+    if (options.preText) {
+      output += `${options.preText}\n\n`;
     }
-    async format(str) {
-        return prettier.format(str, {
-            parser: 'typescript',
-            trailingComma: 'none',
-            tabWidth: 2,
-            printWidth: 130,
-            singleQuote: true,
-            arrowParens: 'avoid'
-        });
+    if (options.variableType) {
+      output += `export const ${options.variableName}: ${options.variableType} = ${this.stringify(options.variable)}`;
+    } else {
+      output += `export const ${options.variableName} = ${this.stringify(options.variable)}`;
     }
-    stringify(obj) {
-        // eslint-disable-next-line no-null/no-null
-        return JSON.stringify(obj, (k, v) => (v === undefined ? null : v)).replace(/null/gm, 'undefined');
+    if (options.replaceMap) {
+      output = this.replaceOutput(output, options.replaceMap);
     }
+    return this.format(output);
+  }
+  convertToRelativePath(filePath, relativePathFromRoot) {
+    let fromPath = context_1.Context.outputPath + filePath.substring(0, filePath.lastIndexOf('/'));
+    let toPath = context_1.Context.config.projectRoot + relativePathFromRoot.substring(1);
+    return path_1.default.relative(fromPath, toPath).replace(/\\/g, '/');
+  }
+  replaceOutput(output, replaceMap) {
+    replaceMap.forEach(item => {
+      output = output.replace(new RegExp(item.target, 'g'), item.replace);
+    });
+    return output;
+  }
+  async format(str) {
+    return prettier.format(str, {
+      parser: 'typescript',
+      trailingComma: 'none',
+      tabWidth: 2,
+      printWidth: 130,
+      singleQuote: true,
+      arrowParens: 'avoid'
+    });
+  }
+  stringify(obj) {
+    // eslint-disable-next-line no-null/no-null
+    return JSON.stringify(obj, (k, v) => (v === undefined ? null : v)).replace(/null/gm, 'undefined');
+  }
 }
 exports.OutputHelper = new OutputHelperClass();
-//# sourceMappingURL=output-helper.js.map
+//# sourceMappingURL=output-helper.js.map

package/dist/helpers/output-helper/output-helper.spec.d.ts

@@ -0,0 +1,24 @@
+export declare const Const: {
+  type: string;
+  material: string;
+  maxQuantity: number;
+  mainHand: undefined;
+  offHand: undefined;
+  bothHands: {
+    imageOnCharacter: string;
+    parryDice: undefined;
+    attacks: {
+      actionIcon: string;
+      attackDices: string[];
+      range: string;
+      requiresSetup: boolean;
+      unparryable: boolean;
+      lowersQuantity: boolean;
+      projectileType: string;
+      sounds: {
+        hit: string;
+        pre: string;
+      };
+    }[];
+  };
+};

package/dist/helpers/output-helper/output-helper.spec.js

@@ -0,0 +1,261 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.Const = void 0;
+const mocks_1 = require('../../_mocks/mocks');
+const context_1 = require('../../framework/context');
+const output_helper_1 = require('./output-helper');
+let complexObject = {
+  type: 'bow',
+  material: 'WoodenItemMaterial',
+  maxQuantity: 10,
+  mainHand: undefined,
+  offHand: undefined,
+  bothHands: {
+    imageOnCharacter: 'BodyPartImageNames',
+    parryDice: undefined,
+    attacks: [
+      {
+        actionIcon: 'AssetNames.characterActionBowAttack',
+        attackDices: ['DiceType.d6', 'DiceType.d6'],
+        range: 'WeaponRange.ranged',
+        requiresSetup: false,
+        unparryable: true,
+        lowersQuantity: true,
+        projectileType: 'ProjectileType.arrow',
+        sounds: {
+          hit: 'AssetGroups.battleSoundArrowHit',
+          pre: 'AssetGroups.battleSoundArrowShot'
+        }
+      }
+    ]
+  }
+};
+let emptyArrayExpected = `export const Groups: any[] = [];
+`;
+let basicArrayExpected = `export const Groups: any[] = [
+  { name: 'test1', source: './src/definitions-sample/images/test1.png' },
+  { name: 'test2', source: './src/definitions-sample/images/test2.png', pixelPerfectInteraction: true }
+];
+`;
+let complexArrayExpected = `export const Groups: any[] = [
+  {
+    type: 'bow',
+    material: 'WoodenItemMaterial',
+    maxQuantity: 10,
+    mainHand: undefined,
+    offHand: undefined,
+    bothHands: {
+      imageOnCharacter: 'BodyPartImageNames',
+      parryDice: undefined,
+      attacks: [
+        {
+          actionIcon: 'AssetNames.characterActionBowAttack',
+          attackDices: ['DiceType.d6', 'DiceType.d6'],
+          range: 'WeaponRange.ranged',
+          requiresSetup: false,
+          unparryable: true,
+          lowersQuantity: true,
+          projectileType: 'ProjectileType.arrow',
+          sounds: { hit: 'AssetGroups.battleSoundArrowHit', pre: 'AssetGroups.battleSoundArrowShot' }
+        }
+      ]
+    }
+  }
+];
+`;
+let complexArrayReplaceExpected = `export const Groups: any[] = [
+  {
+    type: 'bow',
+    material: 'WoodenItemMaterial',
+    maxQuantity: 10,
+    mainHand: undefined,
+    offHand: undefined,
+    bothHands: {
+      imageOnCharacter: 'BodyPartImageNames',
+      parryDice: undefined,
+      attacks: [
+        {
+          actionIcon: 'AssetNames.characterActionBowAttack',
+          attackDices: [DiceType.d6, DiceType.d6],
+          range: 'WeaponRange.ranged',
+          requiresSetup: false,
+          unparryable: true,
+          lowersQuantity: true,
+          projectileType: 'ProjectileType.arrow',
+          sounds: { hit: 'AssetGroups.battleSoundArrowHit', pre: 'AssetGroups.battleSoundArrowShot' }
+        }
+      ]
+    }
+  }
+];
+`;
+exports.Const = {
+  type: 'bow',
+  material: 'WoodenItemMaterial',
+  maxQuantity: 10,
+  mainHand: undefined,
+  offHand: undefined,
+  bothHands: {
+    imageOnCharacter: 'BodyPartImageNames',
+    parryDice: undefined,
+    attacks: [
+      {
+        actionIcon: 'AssetNames.characterActionBowAttack',
+        attackDices: ['DiceType.d6', 'DiceType.d6'],
+        range: 'WeaponRange.ranged',
+        requiresSetup: false,
+        unparryable: true,
+        lowersQuantity: true,
+        projectileType: 'ProjectileType.arrow',
+        sounds: {
+          hit: 'AssetGroups.battleSoundArrowHit',
+          pre: 'AssetGroups.battleSoundArrowShot'
+        }
+      }
+    ]
+  }
+};
+let noTypeExpected = `export const ConstSample = { type: 'item' };
+`;
+let basicConstExpected = `export const ConstSample: string = 'basic';
+`;
+let complexConstExpected = `export const ConstSample: any = {
+  type: 'bow',
+  material: 'WoodenItemMaterial',
+  maxQuantity: 10,
+  mainHand: undefined,
+  offHand: undefined,
+  bothHands: {
+    imageOnCharacter: 'BodyPartImageNames',
+    parryDice: undefined,
+    attacks: [
+      {
+        actionIcon: 'AssetNames.characterActionBowAttack',
+        attackDices: ['DiceType.d6', 'DiceType.d6'],
+        range: 'WeaponRange.ranged',
+        requiresSetup: false,
+        unparryable: true,
+        lowersQuantity: true,
+        projectileType: 'ProjectileType.arrow',
+        sounds: { hit: 'AssetGroups.battleSoundArrowHit', pre: 'AssetGroups.battleSoundArrowShot' }
+      }
+    ]
+  }
+};
+`;
+let complexConstReplaceExpected = `export const ConstSample: any = {
+  type: 'bow',
+  material: 'WoodenItemMaterial',
+  maxQuantity: 10,
+  mainHand: undefined,
+  offHand: undefined,
+  bothHands: {
+    imageOnCharacter: 'BodyPartImageNames',
+    parryDice: undefined,
+    attacks: [
+      {
+        actionIcon: 'AssetNames.characterActionBowAttack',
+        attackDices: ['DiceType.d6', 'DiceType.d6'],
+        range: WeaponRange,
+        requiresSetup: false,
+        unparryable: true,
+        lowersQuantity: true,
+        projectileType: 'ProjectileType.arrow',
+        sounds: { hit: 'AssetGroups.battleSoundArrowHit', pre: 'AssetGroups.battleSoundArrowShot' }
+      }
+    ]
+  }
+};
+`;
+describe('Output Helper: Array Output', () => {
+  test('should handle empty array', async () => {
+    let output = await output_helper_1.OutputHelper.generateArrayOutput({
+      variableName: 'Groups',
+      variableType: 'any[]',
+      variable: []
+    });
+    expect(output).toStrictEqual(emptyArrayExpected);
+  });
+  test('should handle basic array', async () => {
+    let output = await output_helper_1.OutputHelper.generateArrayOutput({
+      variableName: 'Groups',
+      variableType: 'any[]',
+      variable: [
+        { name: 'test1', source: './src/definitions-sample/images/test1.png' },
+        { name: 'test2', source: './src/definitions-sample/images/test2.png', pixelPerfectInteraction: true }
+      ]
+    });
+    expect(output).toStrictEqual(basicArrayExpected);
+  });
+  test('should handle complex array', async () => {
+    let output = await output_helper_1.OutputHelper.generateArrayOutput({
+      variableName: 'Groups',
+      variableType: 'any[]',
+      variable: [complexObject]
+    });
+    expect(output).toStrictEqual(complexArrayExpected);
+  });
+  test('should handle replacing complex array', async () => {
+    let output = await output_helper_1.OutputHelper.generateArrayOutput({
+      variableName: 'Groups',
+      variableType: 'any[]',
+      variable: [complexObject],
+      replaceMap: [{ target: `"DiceType.d6"`, replace: 'DiceType.d6' }]
+    });
+    expect(output).toStrictEqual(complexArrayReplaceExpected);
+  });
+});
+describe('Output Helper: Const Output', () => {
+  test('should handle no type', async () => {
+    let output = await output_helper_1.OutputHelper.generateOutput({ variableName: 'ConstSample', variable: { type: 'item' } });
+    expect(output).toStrictEqual(noTypeExpected);
+  });
+  test('should handle basic value', async () => {
+    let output = await output_helper_1.OutputHelper.generateOutput({
+      variableName: 'ConstSample',
+      variableType: 'string',
+      variable: 'basic'
+    });
+    expect(output).toStrictEqual(basicConstExpected);
+  });
+  test('should handle complex object', async () => {
+    let output = await output_helper_1.OutputHelper.generateOutput({
+      variableName: 'ConstSample',
+      variableType: 'any',
+      variable: complexObject
+    });
+    expect(output).toStrictEqual(complexConstExpected);
+  });
+  test('should handle replacing complex object', async () => {
+    let output = await output_helper_1.OutputHelper.generateOutput({
+      variableName: 'ConstSample',
+      variableType: 'any',
+      variable: complexObject,
+      replaceMap: [{ target: `"WeaponRange.ranged"`, replace: 'WeaponRange' }]
+    });
+    expect(output).toStrictEqual(complexConstReplaceExpected);
+  });
+});
+describe('Output Helper: stringify', () => {
+  test('should not lose properties with undefined or null value', async () => {
+    let output = await output_helper_1.OutputHelper['stringify']({
+      a: undefined,
+      // eslint-disable-next-line no-null/no-null
+      b: null
+    });
+    expect(output).toStrictEqual('{"a":undefined,"b":undefined}');
+  });
+});
+describe('Output Helper: convertToRelativePath', () => {
+  test('should convert to relative path', async () => {
+    (0, mocks_1.resetContext)();
+    context_1.Context.outputPath = 'D:/Projects/Game-Dev/Starfighter/Starfighter-Definitions-Generator/src/.asset-build';
+    context_1.Context.config.projectRoot = 'D:/Projects/Game-Dev/Starfighter/Starfighter-Definitions-Generator/';
+    let original = '.src/definitions-sample/images/nested/test2.png';
+    let desired = '../../../definitions-sample/images/nested/test2.png';
+    let filePath = '/0-global-definitions/assets/images.ts';
+    let output = output_helper_1.OutputHelper['convertToRelativePath'](filePath, original);
+    expect(output).toStrictEqual(desired);
+  });
+});
+//# sourceMappingURL=output-helper.spec.js.map

package/dist/helpers/output-helper/output-helper.test.d.ts

@@ -1,24 +1,24 @@
 export declare const Const: {
-    type: string;
-    material: string;
-    maxQuantity: number;
-    mainHand: undefined;
-    offHand: undefined;
-    bothHands: {
-        imageOnCharacter: string;
-        parryDice: undefined;
-        attacks: {
-            actionIcon: string;
-            attackDices: string[];
-            range: string;
-            requiresSetup: boolean;
-            unparryable: boolean;
-            lowersQuantity: boolean;
-            projectileType: string;
-            sounds: {
-                hit: string;
-                pre: string;
-            };
-        }[];
-    };
+  type: string;
+  material: string;
+  maxQuantity: number;
+  mainHand: undefined;
+  offHand: undefined;
+  bothHands: {
+    imageOnCharacter: string;
+    parryDice: undefined;
+    attacks: {
+      actionIcon: string;
+      attackDices: string[];
+      range: string;
+      requiresSetup: boolean;
+      unparryable: boolean;
+      lowersQuantity: boolean;
+      projectileType: string;
+      sounds: {
+        hit: string;
+        pre: string;
+      };
+    }[];
+  };
 };