definition-generator-framework 1.13.1 → 2.0.0-rc0

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

@@ -1,261 +0,0 @@
-'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 +0,0 @@
-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.test.js

@@ -1,262 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Const = void 0;
-const vitest_1 = require('vitest');
-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' }
-      }
-    ]
-  }
-};
-`;
-(0, vitest_1.describe)('Output Helper: Array Output', () => {
-  (0, vitest_1.test)('should handle empty array', async () => {
-    let output = await output_helper_1.OutputHelper.generateArrayOutput({
-      variableName: 'Groups',
-      variableType: 'any[]',
-      variable: []
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(emptyArrayExpected);
-  });
-  (0, vitest_1.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 }
-      ]
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(basicArrayExpected);
-  });
-  (0, vitest_1.test)('should handle complex array', async () => {
-    let output = await output_helper_1.OutputHelper.generateArrayOutput({
-      variableName: 'Groups',
-      variableType: 'any[]',
-      variable: [complexObject]
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(complexArrayExpected);
-  });
-  (0, vitest_1.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' }]
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(complexArrayReplaceExpected);
-  });
-});
-(0, vitest_1.describe)('Output Helper: Const Output', () => {
-  (0, vitest_1.test)('should handle no type', async () => {
-    let output = await output_helper_1.OutputHelper.generateOutput({ variableName: 'ConstSample', variable: { type: 'item' } });
-    (0, vitest_1.expect)(output).toStrictEqual(noTypeExpected);
-  });
-  (0, vitest_1.test)('should handle basic value', async () => {
-    let output = await output_helper_1.OutputHelper.generateOutput({
-      variableName: 'ConstSample',
-      variableType: 'string',
-      variable: 'basic'
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(basicConstExpected);
-  });
-  (0, vitest_1.test)('should handle complex object', async () => {
-    let output = await output_helper_1.OutputHelper.generateOutput({
-      variableName: 'ConstSample',
-      variableType: 'any',
-      variable: complexObject
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(complexConstExpected);
-  });
-  (0, vitest_1.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' }]
-    });
-    (0, vitest_1.expect)(output).toStrictEqual(complexConstReplaceExpected);
-  });
-});
-(0, vitest_1.describe)('Output Helper: stringify', () => {
-  (0, vitest_1.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
-    });
-    (0, vitest_1.expect)(output).toStrictEqual('{"a":undefined,"b":undefined}');
-  });
-});
-(0, vitest_1.describe)('Output Helper: convertToRelativePath', () => {
-  (0, vitest_1.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);
-    (0, vitest_1.expect)(output).toStrictEqual(desired);
-  });
-});
-//# sourceMappingURL=output-helper.test.js.map

package/dist/helpers/raw-definition-helper/raw-definition.helper.d.ts

@@ -1,7 +0,0 @@
-import { RawDefinition } from '../../framework/interfaces';
-export declare class RawDefinitionHelper {
-    static findLine(rawDefinition: RawDefinition, path: readonly (string | number)[]): number;
-    static flatten(rawDefinition: RawDefinition): any;
-    private static findLineRawData;
-    private static flattenRawData;
-}

package/dist/helpers/raw-definition-helper/raw-definition.helper.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawDefinitionHelper = void 0;
-const helpers_lib_1 = require("helpers-lib");
-class RawDefinitionHelper {
-    static findLine(rawDefinition, path) {
-        if (path.length === 0) {
-            return rawDefinition.parsedStructure.line;
-        }
-        else {
-            let line;
-            let remainingPaths = [...path];
-            // For broken 'required' paths, the path itself is also wrong so we need to find the closest line in such cases
-            while (line === undefined && remainingPaths.length > 0) {
-                line = this.findLineRawData(rawDefinition.parsedStructure.rawData, [...remainingPaths]);
-                remainingPaths.pop();
-            }
-            return line || rawDefinition.parsedStructure.line;
-        }
-    }
-    static flatten(rawDefinition) {
-        return this.flattenRawData(rawDefinition.parsedStructure.rawData);
-    }
-    static findLineRawData(rawData, path) {
-        let firstPath = path.shift();
-        let selectedStructure;
-        if (rawData && firstPath !== undefined) {
-            if (helpers_lib_1.Comparator.isNumber(firstPath)) {
-                if (helpers_lib_1.Comparator.isArray(rawData)) {
-                    selectedStructure = rawData[firstPath];
-                }
-            }
-            else {
-                if (helpers_lib_1.Comparator.isObject(rawData)) {
-                    selectedStructure = rawData[firstPath];
-                }
-            }
-        }
-        if (selectedStructure) {
-            if (path.length === 0) {
-                return selectedStructure.line;
-            }
-            else {
-                return this.findLineRawData(selectedStructure.rawData, path);
-            }
-        }
-    }
-    static flattenRawData(rawData) {
-        if (helpers_lib_1.Comparator.isArray(rawData)) {
-            return rawData.map(parsedStructure => this.flattenRawData(parsedStructure.rawData));
-        }
-        else if (helpers_lib_1.Comparator.isObject(rawData)) {
-            let objectRawData = rawData;
-            return Object.keys(objectRawData).reduce((acc, key) => {
-                let parsedStructure = objectRawData[key];
-                acc[key] = this.flattenRawData(parsedStructure.rawData);
-                return acc;
-            }, {});
-        }
-        else {
-            return rawData;
-        }
-    }
-}
-exports.RawDefinitionHelper = RawDefinitionHelper;
-//# sourceMappingURL=raw-definition.helper.js.map

package/dist/helpers/raw-definition-helper/raw-definition.helper.spec.d.ts

@@ -1 +0,0 @@
-export {};