@design-core/core 0.0.1 → 0.0.3

package/core/styles/styleManagerBase.js

@@ -1,299 +0,0 @@
-import {DesignCore} from '../designCore.js';
-import {Strings} from '../lib/strings.js';
-
-export class StyleManagerBase {
-  constructor() {
-    this.styles = [];
-    this.addStandardStyles();
-    // set the current style to the first available style
-    this.currentstyle = this.styles[0].name;
-
-    // list of mandatory styles or layers that cannot be deleted
-    this.indelibleStyles = [];
-  }
-
-  /**
-   * Get styles
-   * @returns list of styles
-   */
-  getStyles() {
-    return this.styles;
-  }
-
-  /**
-   * Get style count
-   * @returns number of styles
-   */
-  styleCount() {
-    return this.styles.length;
-  }
-
-  /**
-   * Adds a new style to the list of active styles
-   */
-  newStyle() {
-    this.addStyle({
-      'name': this.getUniqueName('NEW_STYLE'),
-    });
-  }
-
-  /**
-   * Generate a unique name
-   * @param {string} name
-   * @returns unique name
-   */
-  getUniqueName(name) {
-    let count = 0;
-    let styStr = name.replace(/ /g, '_'); // .toUpperCase();
-    for (let i = 0; i < this.styleCount(); i++) {
-      const styleName = this.styles[i].name.toUpperCase();
-      if (styleName.includes(styStr.toUpperCase())) {
-        count = count + 1;
-      }
-    }
-    if (count > 0) {
-      styStr = styStr + '_' + count;
-    }
-
-    return styStr;
-  };
-
-  /**
-   * Add a style to the list of styles
-   * @param {style} style
-   */
-  addStyle(style, overwrite=false) {
-    // Call the subclass to create a new typed style object
-    const newStyle = this.createStyle(style);
-    const newStyleName = newStyle.name;
-    if (!this.styleExists(newStyleName)) {
-      this.styles.push(newStyle);
-    } else if (overwrite) {
-      // Overwrite The style existing style
-      // This is used when loading files;
-      // Standard styles already exist but should be overwritten by the incoming style
-      this.styles.splice(this.getStyleIndex(newStyleName), 1, newStyle);
-    }
-    // DesignCore.Scene.saveRequired();
-  }
-
-  /**
-   * Delete a style using the style index
-   * @param {number} styleIndex
-   * @returns undefined
-   */
-  deleteStyle(styleIndex) {
-    if (this.styles[styleIndex] === undefined) {
-      return;
-    }
-
-    const styleToDelete = this.getStyleByIndex(styleIndex).name;
-
-    // Can't delete indelible styles (Standard Text Style, Layer 0)
-    if (this.indelibleStyles.some((style) => style.toUpperCase() === styleToDelete.toUpperCase())) {
-      DesignCore.Core.notify(`${styleToDelete} ${Strings.Message.CANNOTBEDELETED}`);
-      return;
-    }
-
-    // Can't delete current style
-    if (styleToDelete.toUpperCase() === this.currentstyle.toUpperCase()) {
-      DesignCore.Core.notify(Strings.Message.CSTYLEDELETE);
-      return;
-    }
-
-    // delete all item using the selected style
-    this.deleteStyleFromScene(styleToDelete);
-
-    // Delete The style
-    this.styles.splice(styleIndex, 1);
-  }
-
-  /**
-   * Delete all items that use style
-   * @param {string} style
-   */
-  deleteStyleFromScene(style) {
-    const selectionSet = [];
-
-    for (let i = 0; i <DesignCore.Scene.items.length; i++) {
-      if (DesignCore.Scene.items[i][this.styleProperty] === style) {
-        selectionSet.push(i);
-      }
-    }
-
-    // sort the selection in descending order
-    selectionSet.sort((a, b)=>b-a);
-
-    for (let j = 0; j < selectionSet.length; j++) {
-      DesignCore.Scene.items.splice((selectionSet[j]), 1);
-    }
-  }
-
-  /**
-   * Get the name of the current style
-   */
-  getCstyle() {
-    return this.currentstyle;
-  }
-
-  /**
-   * Set the current style
-   * @param {string} cstyle
-   */
-  setCstyle(cstyle) {
-    if (this.getStyleByName(cstyle) !== undefined) {
-      this.currentstyle = cstyle;
-    }
-  }
-
-  /**
-   * Check if a style with styleName exists
-   * @param {string} styleName
-   * @returns true or false
-   */
-  styleExists(styleName) {
-    const styleExists = this.styles.some((el) => el.name.toUpperCase() === styleName.toUpperCase());
-    return styleExists;
-  }
-
-  /**
-   * Ensure that used styles and default styles exist
-   */
-  checkStyles() {
-    if (!this.styleCount()) {
-      this.addStandardStyles();
-    }
-
-    for (let i = 0; i < DesignCore.Scene.items.length; i++) {
-      const style = (DesignCore.Scene.getItem(i)[this.styleProperty]);
-      this.addStyle({
-        'name': style,
-      });
-    }
-  }
-
-  /**
-   * Clear all existing styles
-   */
-  clearStyles() {
-    this.styles = [];
-  }
-
-  /**
-   * Find the index of styleName
-   * @param {string} styleName
-   * @returns index of the style or -1 if style doesn't exist
-   */
-  getStyleIndex(styleName) {
-    return this.styles.findIndex((style) => style.name.toUpperCase() === styleName.toUpperCase());
-  }
-
-  /**
-   * get a style matching stylename
-   * @param {string} styleName
-   * @returns style object
-   */
-  getStyleByName(styleName) {
-    for (let i = 0; i < this.styleCount(); i++) {
-      if (this.styles[i].name.toUpperCase() === styleName.toUpperCase()) {
-        return this.styles[i];
-      }
-    }
-
-    const msg = 'Invalid Style Name';
-    const err = (`${this.constructor.name} - ${msg}: ${styleName}`);
-    throw Error(err);
-
-    // return;
-  }
-
-  /**
-   * Get the style from an index
-   * @param {number} styleIndex
-   * @returns
-   */
-  getStyleByIndex(styleIndex) {
-    return this.styles[styleIndex];
-  }
-
-
-  /**
-   * Rename the style at index with newName
-   * @param {number} styleIndex
-   * @param {string} newName
-   * @returns undefined
-   */
-  renameStyle(styleIndex, newName) {
-    const styleToRename = this.getStyleByIndex(styleIndex).name;
-
-    // make sure it is a new name
-    if (styleToRename.toUpperCase() === newName.toUpperCase()) {
-      return;
-    }
-
-    // Can't rename indelible styles (Standard Text Style, Layer 0)
-    if (this.indelibleStyles.some((style) => style.toUpperCase() === styleToRename.toUpperCase())) {
-      DesignCore.Core.notify(`${styleToRename} ${Strings.Message.CANNOTBERENAMED}`);
-      return;
-    }
-
-    // Can't rename indelible styles (Standard Text Style, Layer 0)
-    if (this.indelibleStyles.some((style) => style.toUpperCase() === newName.toUpperCase())) {
-      DesignCore.Core.notify(`${newName} ${Strings.Message.CANNOTBERENAMED}`);
-      return;
-    }
-
-    const newUniqueName = this.getUniqueName(newName);
-
-    const currentStyleName = this.styles[styleIndex].name;
-    this.styles[styleIndex].name = newUniqueName;
-
-    // update all scene items with the new style value
-    this.updateSceneStyle(currentStyleName, newUniqueName);
-
-    // if the style to change is the current style, update the currentstyle property
-    if (currentStyleName === this.currentstyle) {
-      this.setCstyle(newUniqueName);
-    }
-  }
-
-  /**
-   * Update all items that use style
-   * @param {string} oldStyleName
-   * @param {string} newStyleName
-   */
-  updateSceneStyle(oldStyleName, newStyleName) {
-    for (let i = 0; i <DesignCore.Scene.items.length; i++) {
-      if (DesignCore.Scene.items[i][this.styleProperty] === oldStyleName) {
-        DesignCore.Scene.items[i][this.styleProperty] = newStyleName;
-      }
-    }
-  }
-
-  /**
-   * Update the style property with value
-   * @param {number} styleIndex
-   * @param {string} property
-   * @param {any} value
-   */
-  updateStyle(styleIndex, property, value) {
-    // check of the index exists
-    if (this.styles[styleIndex] === undefined) {
-      const msg = 'Invalid Style Index';
-      const err = (`${this.type} - ${msg}`);
-      throw Error(err);
-    }
-
-    if (this.styles[styleIndex][property] === undefined) {
-      const msg = 'Invalid Style Property';
-      const err = (`${this.type} - ${msg}`);
-      throw Error(err);
-    }
-
-    if (property.toUpperCase() === 'NAME') {
-      this.renameStyle(styleIndex, value);
-    } else {
-      this.styles[styleIndex][property] = value;
-    }
-  }
-}

package/test/entities/block.test.js

@@ -1,22 +0,0 @@
-import {Block} from '../../core/entities/block.js';
-import {Line} from '../../core/entities/line.js';
-import {Point} from '../../core/entities/point.js';
-
-test('Test Block.boundingBox', () => {
-  const block = new Block();
-  const line = new Line({points: [new Point(101, 102), new Point(201, 202)]});
-  block.addItem(line);
-
-  expect(block.boundingBox().xMin).toBeCloseTo(101);
-  expect(block.boundingBox().xMax).toBeCloseTo(201);
-  expect(block.boundingBox().yMin).toBeCloseTo(102);
-  expect(block.boundingBox().yMax).toBeCloseTo(202);
-
-  const line2 = new Line({points: [new Point(1001, 1002), new Point(2001, 2002)]});
-  block.addItem(line2);
-
-  expect(block.boundingBox().xMin).toBeCloseTo(101);
-  expect(block.boundingBox().xMax).toBeCloseTo(2001);
-  expect(block.boundingBox().yMin).toBeCloseTo(102);
-  expect(block.boundingBox().yMax).toBeCloseTo(2002);
-});

package/test/styles/dimstyle.test.js

@@ -1,19 +0,0 @@
-import {DimStyle} from '../../core/styles/dimStyle';
-
-test('Test DimStyle.getValue', () => {
-  const style = new DimStyle();
-  expect(style.getValue('DIMSE1')).toBe(false);
-  expect(style.getValue('DIMASZ')).toBe(2.5);
-});
-
-test('Test DimStyle.vertical', () => {
-  const style = new DimStyle();
-  expect(style.vertical).toBe(false);
-  expect(style.standardFlags).toBe(0);
-
-  style.vertical = true;
-  expect(style.vertical).toBe(true);
-  expect(style.standardFlags).toBe(4);
-});
-
-

package/test/styles/layerManager.test.js

@@ -1,150 +0,0 @@
-import {Core} from '../../core/core/core.js';
-import {Point} from '../../core/entities/point.js';
-
-const core = new Core();
-const layerManager = core.layerManager;
-
-test('Test LayerManager.getStyles', () => {
-  const layers = layerManager.getStyles();
-  expect(layers).toHaveLength(2);
-
-  expect(layers[0]).toHaveProperty('name', '0');
-  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
-});
-
-test('Test LayerManager.styleCount', () => {
-  const count = layerManager.styleCount();
-  expect(count).toBe(2);
-});
-
-test('Test LayerManager.newStyle', () => {
-  const count = layerManager.styleCount();
-  layerManager.newStyle();
-  expect(layerManager.styleCount()).toBe(count + 1);
-});
-
-test('Test LayerManager.getUniqueName', () => {
-  // existing defpoints layer
-  let name = layerManager.getUniqueName('DEFPOINTS');
-  expect(name).toBe('DEFPOINTS_1');
-  // existing NEW_LAYER layer
-  name = layerManager.getUniqueName('NEW_STYLE');
-  expect(name).toBe('NEW_STYLE_1');
-  // unique layer
-  name = layerManager.getUniqueName('UNIQUE_LAYER');
-  expect(name).toBe('UNIQUE_LAYER');
-});
-
-test('Test LayerManager.addStyle', () => {
-  const count = layerManager.styleCount();
-  layerManager.addStyle({'name': 'test', 'colour': '#00BFFF'});
-  expect(layerManager.styleCount()).toBe(count + 1);
-});
-
-test('Test LayerManager.deleteStyle', () => {
-  const count = layerManager.styleCount();
-  // defpoints can't be deleted
-  layerManager.deleteStyle('DEFPOINTS');
-  expect(layerManager.styleCount()).toBe(count);
-
-  // clayer can't be deleted
-  layerManager.deleteStyle(layerManager.getCstyle());
-  expect(layerManager.styleCount()).toBe(count);
-
-  // test should be deleted
-  layerManager.deleteStyle(layerManager.getStyleIndex('test'));
-  expect(layerManager.styleCount()).toBe(count - 1);
-});
-
-test('Test LayerManager.deleteStyle', () => {
-  const count = layerManager.styleCount();
-  layerManager.deleteStyle(2);
-  expect(layerManager.styleCount()).toBe(count - 1);
-});
-
-test('Test LayerManager.getCstyle', () => {
-  const clayer = layerManager.getCstyle();
-  expect(clayer).toBe('0');
-});
-
-test('Test LayerManager.setCstyle', () => {
-  const layer = layerManager.getStyles().at(-1).name;
-  layerManager.setCstyle(layer);
-  expect(layerManager.getCstyle()).toBe(layer);
-});
-
-test('Test LayerManager.styleExists', () => {
-  expect(layerManager.styleExists('DEFPOINTS')).toBe(true);
-  expect(layerManager.styleExists('OBSCURE_LAYER_NAME')).toBe(false);
-});
-
-test('Test LayerManager.checkStyles', () => {
-  layerManager.layers = [];
-
-  const newStyleName = 'checkStyles';
-  const startPoint = new Point();
-  const endPoint = new Point(10, 10);
-
-  const data = {
-    points: [startPoint, endPoint],
-    colour: '#FFFFFF',
-    layer: newStyleName,
-  };
-
-  core.scene.addItem('Line', data, false);
-
-  layerManager.checkStyles();
-  const layers = layerManager.getStyles();
-  expect(layers).toHaveLength(3);
-
-  expect(layers[0]).toHaveProperty('name', '0');
-  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
-  expect(layers[2]).toHaveProperty('name', newStyleName);
-});
-
-test('Test LayerManager.addStandardStyles', () => {
-  layerManager.clearStyles();
-
-  layerManager.addStandardStyles();
-
-  const layers = layerManager.getStyles();
-  expect(layers).toHaveLength(2);
-
-  expect(layers[0]).toHaveProperty('name', '0');
-  expect(layers[1]).toHaveProperty('name', 'DEFPOINTS');
-});
-
-test('Test LayerManager.getStyleIndex', () => {
-  layerManager.addStyle({'name': 'addStyle', 'colour': '#00BFFF'});
-  // get index for test layer - should be the last layer
-  expect(layerManager.getStyleIndex('addStyle')).toBe(layerManager.styleCount() - 1);
-  // get index for a layer that doesn't exist
-  expect(layerManager.getStyleIndex('no-exist')).toBe(-1);
-});
-
-test('Test LayerManager.getStyleByName', () => {
-  layerManager.addStyle({'name': 'test'});
-  const layer = layerManager.getStyleByName('test');
-  expect(layer.name).toBe('test');
-  // get a layer that doesn't exist
-  expect(() => {
-    layerManager.getStyleByName('no-exist');
-  }).toThrow();
-});
-
-test('Test LayerManager.getStyleByIndex', () => {
-  const testLayer = layerManager.getStyleByName('test');
-  const layer = layerManager.getStyleByIndex(layerManager.getStyleIndex('test'));
-  expect(testLayer === layer).toBe(true);
-  // get a layer that doesn't exist
-  expect(layerManager.getStyleByIndex(1000)).toBeUndefined();
-});
-
-test('Test LayerManager.renameStyle', () => {
-  const index = layerManager.getStyleIndex('test');
-  const newStylename = 'RENAMED_TEST';
-  layerManager.renameStyle(index, newStylename);
-
-  expect(layerManager.getStyleIndex(newStylename)).toBe(index);
-  expect(layerManager.getStyleIndex('test')).toBe(-1);
-});

package/test/styles/style.test.js

@@ -1,33 +0,0 @@
-import {Style} from '../../core/styles/style';
-
-test('Test Style.vertical', () => {
-  const style = new Style();
-  expect(style.vertical).toBe(false);
-  expect(style.standardFlags).toBe(0);
-
-  style.vertical = true;
-  expect(style.vertical).toBe(true);
-  expect(style.standardFlags).toBe(4);
-});
-
-
-test('Test Style.backwards', () => {
-  const style = new Style();
-  expect(style.backwards).toBe(false);
-  expect(style.flags).toBe(0);
-
-  style.backwards = true;
-  expect(style.backwards).toBe(true);
-  expect(style.flags).toBe(2);
-});
-
-test('Test Style.upsideDown', () => {
-  const style = new Style();
-  expect(style.upsideDown).toBe(false);
-  expect(style.flags).toBe(0);
-
-  style.upsideDown = true;
-  expect(style.upsideDown).toBe(true);
-  expect(style.flags).toBe(4);
-});
-