@design-core/core 0.0.1 → 0.0.3

package/core/lib/inputManager.js

@@ -1,122 +1,27 @@
-import {Tool} from '../tools/tool.js';
-import {Snapping} from './snapping.js';
-import {Utils} from './utils.js';
-
-import {DesignCore} from '../designCore.js';
-
-export class PromptOptions {
-  constructor(promptMessage = 'error', types = [], options = []) {
-    this.promptMessage = promptMessage;
-    this.types = types;
-    this.options = options;
-    this.resolve = undefined;
-    this.reject = undefined;
-  }
-
-  /**
-   * Return data to the input request
-   * @param {any} input
-   */
-  respond(input) {
-    if (this.types.includes(Input.getType(input))) {
-      // expected type input, pass to active command
-      this.resolve(input);
-    } else if (this.parseInputToOption(input) !== undefined) {
-      // input matches command option, pass to active command
-      this.resolve(this.parseInputToOption(input));
-    } else {
-      throw Error('Invalid response type');
-    }
-  }
-
-  /**
-   * Match the input to a command option
-   * @param {any} input
-   * @returns undefined or the matched option
-   */
-  parseInputToOption(input) {
-    if (this.options.length === 0) {
-      return;
-    }
-
-    for (let i = 0; i < this.options.length; i++) {
-      const option = this.options[i];
-      // convert the option to uppercase and substring to the input length for comparison
-      const optionSubstring = option.toUpperCase().substring(0, input.length);
-      if (optionSubstring === input.toUpperCase()) {
-        return option;
-      }
-    }
-
-    return;
-  }
+import { Tool } from '../tools/tool.js';
+import { Snapping } from './snapping.js';
+import { Utils } from './utils.js';
 
-  /**
-   * Reject the input request
-   */
-  reject() {
-    this.reject();
-  }
+import { DesignCore } from '../designCore.js';
+import { Point } from '../entities/point.js';
+import { Input, MouseDown, MouseUp } from './input.js';
 
-  /**
-   * Return the prompt for the input request
-   * @returns
-   */
-  getPrompt() {
-    let msg = `${this.promptMessage}`;
-    if (this.options.length) {
-      msg = `${this.promptMessage} [${this.options}]`;
-    }
-    return msg;
-  }
-
-  /**
-   * Set the resolve callback
-   * @param {any} resolve - callback function
-   */
-  setResolve(resolve) {
-    this.resolve = resolve;
-  }
-
-  /**
-   * Set the reject callback
-   * @param {any} reject - callback function
-   */
-  setReject(reject) {
-    this.reject = reject;
-  }
-}
-
-export class Input {
-  static Type = {
-    POINT: 'Point',
-    SELECTIONSET: 'SelectionSet',
-    SINGLESELECTION: 'SingleSelection',
-    NUMBER: 'Number',
-    STRING: 'String',
-  };
-
-  /**
-   * Return the Input.Type for value
-   * @param {any} value
-   * @returns
-   */
-  static getType(value) {
-    if (value === undefined) {
-      throw Error('Input.Type: Undefined input type');
-    }
-
-    return value.constructor.name;
-  }
-}
+export { Input, MouseDown, MouseUp } from './input.js';
+export { PromptOptions } from './promptOptions.js';
 
+/** InputManager Class */
 export class InputManager {
+  /** Create InputManager */
   constructor() {
     this.activeCommand = undefined;
 
     this.selection = undefined;
     this.promptOption = undefined;
 
+    // save the last point input
+    // this is needed for snapping, polar, ortho etc.
+    this.inputPoint = null;
+
     this.snapping = new Snapping();
   }
 
@@ -125,17 +30,23 @@ export class InputManager {
    */
   reset() {
     this.snapping.active = false;
+    this.inputPoint = null;
     DesignCore.CommandLine.resetPrompt();
     this.activeCommand = undefined;
-    // this.promptOption.reject('reject');
+
+    if (this.promptOption) {
+      this.promptOption.cancel();
+    }
+
     this.promptOption = undefined;
     DesignCore.Scene.reset();
+    DesignCore.Canvas.setCursorForInputTypes([]);
   }
 
   /**
  * Create input request
  * @param {PromptOption} promptOption
- * @returns promise
+ * @return {Object} promise
  */
   requestInput(promptOption) {
     this.promptOption = promptOption;
@@ -152,14 +63,25 @@ export class InputManager {
       }
     });
 
-    if (promptOption.types.includes(Input.Type.POINT)) {
-      // turn on snapping
-      this.snapping.active = true;
-    }
+    this.snapping.active = promptOption.types.includes(Input.Type.POINT);
+    DesignCore.Canvas.setCursorForInputTypes(promptOption.types, promptOption.cursor);
+
+    return promptOption.createPromise().then((input) => {
+      if (input === undefined) return undefined;
+
+      // Handle DYNAMIC: convert number to projected point
+      if (promptOption.types.includes(Input.Type.DYNAMIC) && !isNaN(input)) {
+        const angle = this.inputPoint.angle(DesignCore.Mouse.pointOnScene());
+        input = this.inputPoint.project(angle, input);
+      }
 
-    return new Promise((resolve, reject) => {
-      this.promptOption.setResolve(resolve);
-      this.promptOption.setReject(reject);
+      // Track the last input point
+      if (input instanceof Point) {
+        this.inputPoint = input;
+      }
+
+      this.snapping.active = false;
+      return input;
     });
   }
 
@@ -168,22 +90,79 @@ export class InputManager {
    * @param {any} input
    */
   onCommand(input) {
+    // If the active prompt would accept this input, pass it through directly
+    if (this.activeCommand !== undefined && this.promptOption) {
+      const accepted = this.promptOption.acceptsInput(input) ||
+                       this.promptOption.parseInputToOption(input) !== undefined;
+      if (accepted) {
+        this.promptOption.respond(input);
+        return;
+      }
+    }
+
+    // If it's a recognised command/shortcut, switch commands without
+    // passing through the prompt (avoids a spurious invalid-input notification)
+    if (DesignCore.CommandManager.isCommandOrShortcut(input)) {
+      this.startCommand(input);
+      return;
+    }
+
+    // Input is neither accepted by the prompt nor a command — let the prompt notify
     if (this.activeCommand !== undefined) {
-      this.promptOption.respond(input);
-    } else if (DesignCore.CommandManager.isCommand(input) || DesignCore.CommandManager.isShortcut(input)) {
-      this.initialiseItem(DesignCore.CommandManager.getCommand(input));
-      this.activeCommand.execute();
+      this.handlePromptInput(input);
+    }
+  }
+
+  /**
+   * Handle a command triggered by a UI button press.
+   * Always resets any active command and starts the new one,
+   * bypassing the active prompt entirely.
+   * @param {string} command
+   */
+  onCommandButton(command) {
+    if (DesignCore.CommandManager.isCommandOrShortcut(command)) {
+      this.startCommand(command);
     }
   }
 
+  /**
+   * Reset any active command and start a new one.
+   * @param {string} command - command name or shortcut
+   */
+  startCommand(command) {
+    if (this.activeCommand !== undefined) {
+      this.reset();
+    }
+
+    const resolvedCommand = DesignCore.CommandManager.getCommand(command);
+    DesignCore.CommandLine.addToCommandHistory(resolvedCommand);
+    this.activeCommand = DesignCore.CommandManager.createNew(resolvedCommand);
+    this.activeCommand.execute();
+  }
+
+  /**
+   * Try to handle input with the active prompt
+   * @param {any} input
+   * @return {boolean} true if handled
+   */
+  handlePromptInput(input) {
+    if (!this.promptOption) {
+      return false;
+    }
+
+    return this.promptOption.respond(input);
+  }
+
   /**
    * Handle enter / return presses
    */
   onEnterPressed() {
     if (this.activeCommand !== undefined) {
-      if (this.promptOption.types.includes(Input.Type.SELECTIONSET) && DesignCore.Scene.selectionManager.selectionSet.accepted !== true) {
+      if (this.promptOption?.types.includes(Input.Type.SELECTIONSET) && DesignCore.Scene.selectionManager.selectionSet.accepted !== true) {
         DesignCore.Scene.selectionManager.selectionSet.accepted = true;
         this.promptOption.respond(DesignCore.Scene.selectionManager.selectionSet);
+      } else if (this.promptOption?.defaultValue !== undefined) {
+        this.promptOption.respond(this.promptOption.defaultValue);
       } else {
         this.reset();
       }
@@ -191,8 +170,7 @@ export class InputManager {
       const lastCommand = DesignCore.CommandLine.lastCommand[0];
       // if there was a previous command - repeat it...
       if (lastCommand) {
-        this.initialiseItem(lastCommand);
-        this.activeCommand.execute();
+        this.startCommand(lastCommand);
       }
     }
   }
@@ -226,7 +204,12 @@ export class InputManager {
     // Select entity only mouse is close to an entity and no snap point is available
     // Do allow selection when there is no command active
     // Don't allow selection of there is an active command that does't require a selection i.e. prompt option includes SINGLESELECTION
-    if (index !== undefined && !snap && (this.activeCommand === undefined || this.promptOption !== undefined && (this.promptOption.types.includes(Input.Type.SINGLESELECTION)|| this.promptOption.types.includes(Input.Type.SELECTIONSET)))) {
+    const canSelectEntity = index !== undefined && !snap &&
+      (this.activeCommand === undefined ||
+        this.promptOption?.types.includes(Input.Type.SINGLESELECTION) ||
+        this.promptOption?.types.includes(Input.Type.SELECTIONSET));
+
+    if (canSelectEntity) {
       const selection = DesignCore.Scene.selectionManager.singleSelect(DesignCore.Mouse.pointOnScene());
       this.onSelection(selection);
     } else if (this.promptOption !== undefined && this.promptOption.types.includes(Input.Type.POINT)) {
@@ -239,42 +222,42 @@ export class InputManager {
    * Handle mouse position changes
    */
   mouseMoved() {
-    DesignCore.Scene.tempItems = [];
-    DesignCore.Scene.auxiliaryItems = [];
+    DesignCore.Scene.tempEntities.clear();
+    DesignCore.Scene.auxiliaryEntities.clear();
 
-    // selection window active
     if (DesignCore.Mouse.buttonOneDown) {
-      if (this.promptOption !== undefined) {
-        // check if the active command requires a selection set
-        if (!this.promptOption.types.includes(Input.Type.SELECTIONSET)) {
-          return;
-        }
-      }
+      const windowSelect = (this.activeCommand === undefined && !this.promptOption) ||
+        this.promptOption?.types.includes(Input.Type.SELECTIONSET);
 
-      DesignCore.Scene.selectionManager.drawSelectionWindow();
-    }
-
-    // store the snapped point
-    let snapped;
-    let selecting = false;
-    if (this.snapping.active) {
-      snapped = this.snapping.snap();
+      if (windowSelect) {
+        DesignCore.Scene.selectionManager.drawSelectionWindow();
+      }
     }
 
-    // Determine if the mouse is over a scene item only if no snap point is available
-    if (snapped === undefined) {
-      if (this.activeCommand === undefined || this.activeCommand !== undefined && (this.promptOption.types.includes(Input.Type.SINGLESELECTION) || this.promptOption.types.includes(Input.Type.SELECTIONSET))) {
-        const index = DesignCore.Scene.selectionManager.findClosestItem(DesignCore.Mouse.pointOnScene());
-        if (index !== undefined) {
-          const copyofitem = Utils.cloneObject(DesignCore.Scene.items[index]);
-          // copyofitem.colour = DesignCore.Core.settings.selecteditemscolour.toString();
-          copyofitem.lineWidth = copyofitem.lineWidth * 2;
-          DesignCore.Scene.addToTempItems(copyofitem);
-          selecting = true;
-        }
+    const snapped = this.snapping.snap();
+
+    // Apply polar/ortho snap and draw the tracking line only when no entity snap is active,
+    // a previous point exists, and no mouse buttons are down
+    if (!snapped &&
+      this.snapping.active &&
+      this.inputPoint !== null &&
+      !DesignCore.Mouse.buttonOneDown &&
+      !DesignCore.Mouse.buttonTwoDown &&
+      !DesignCore.Mouse.buttonThreeDown) {
+      let trackPoint;
+      if (DesignCore.Settings.polar) {
+        trackPoint = this.snapping.polarSnap(this.inputPoint);
+      } else if (DesignCore.Settings.ortho) {
+        trackPoint = this.snapping.orthoSnap(this.inputPoint);
+      }
+      if (trackPoint) {
+        DesignCore.Mouse.setPosFromScenePoint(trackPoint);
+        this.snapping.addTrackingLine(this.inputPoint, trackPoint);
       }
     }
 
+    const selecting = !snapped && this.highlightEntityUnderMouse();
+
     // preview active commands when items are not being selected
     if (this.activeCommand !== undefined && !selecting) {
       this.activeCommand.preview();
@@ -283,34 +266,57 @@ export class InputManager {
     DesignCore.Canvas.requestPaint();
   }
 
+  /**
+   * Highlight the entity under the mouse cursor
+   * @return {boolean} true if an entity was highlighted
+   */
+  highlightEntityUnderMouse() {
+    if (DesignCore.Mouse.buttonOneDown || DesignCore.Mouse.buttonTwoDown || DesignCore.Mouse.buttonThreeDown) {
+      return false;
+    }
+
+    if (this.activeCommand !== undefined &&
+      !this.promptOption?.types.includes(Input.Type.SINGLESELECTION) &&
+      !this.promptOption?.types.includes(Input.Type.SELECTIONSET)) {
+      return false;
+    }
+
+    const index = DesignCore.Scene.selectionManager.findClosestItem(DesignCore.Mouse.pointOnScene());
+    if (index !== undefined) {
+      DesignCore.Scene.tempEntities.add(Utils.cloneObject(DesignCore.Scene.entities.get(index)));
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Handle single selection
    */
   singleSelect() {
-    // console.log('single select');
-    const point = DesignCore.Mouse.pointOnScene();
-    this.onLeftClick(point);
+    this.inputPoint = DesignCore.Mouse.pointOnScene();
+    this.onLeftClick(this.inputPoint);
   }
 
   /**
    * Handle window selection
    */
   windowSelect() {
-    // console.log('window select');
     DesignCore.Scene.selectionManager.windowSelect();
   }
 
 
   /**
  * Handle mouse down
- * @param {integer} button
+ * @param {number} button
  */
   mouseDown(button) {
     switch (button) {
       case 0: // left button
-        // TODO: can't select and window select at the same time
-        // This needs combining with canvas.mouseMove to define selection, snapping and window selection
         this.singleSelect();
+        if (this.promptOption?.types.includes(Input.Type.MOUSEDOWN)) {
+          this.promptOption.resolve?.(new MouseDown());
+        }
         break;
       case 1: // middle button
         break;
@@ -321,19 +327,22 @@ export class InputManager {
 
   /**
  * Handle mouse up
- * @param {integer} button
+ * @param {number} button
  */
   mouseUp(button) {
     switch (button) {
       case 0: // left button
         // Clear tempItems - This is here to remove the crossing window
-        DesignCore.Scene.auxiliaryItems = [];
+        DesignCore.Scene.auxiliaryEntities.clear();
+        if (this.promptOption?.types.includes(Input.Type.MOUSEUP)) {
+          this.promptOption.resolve?.(new MouseUp());
+          return;
+        }
 
-        if (this.promptOption !== undefined) {
-          // check if the active command requires a selection set
-          if (!this.promptOption.types.includes(Input.Type.SELECTIONSET)) {
-            return;
-          }
+        // Skip window selection when there is an active prompt or command, unless it is a selection set
+        if ((this.promptOption !== undefined || this.activeCommand !== undefined) &&
+            !this.promptOption?.types.includes(Input.Type.SELECTIONSET)) {
+          return;
         }
 
         // check if the mouse position has changed since mousedown
@@ -352,43 +361,36 @@ export class InputManager {
 
   /**
    * Handle canvas selection
-   * @param {*} selection
+   * @param {Selection} selection
    */
   onSelection(selection) {
-    if (this.activeCommand !== undefined && this.promptOption.types.includes(Input.Type.SINGLESELECTION)) {
+    if (this.activeCommand !== undefined && this.promptOption?.types.includes(Input.Type.SINGLESELECTION)) {
       this.promptOption.respond(selection);
-    } else {
-      if (Input.getType(selection) === Input.Type.SINGLESELECTION) {
-        DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedItemIndex);
-      }
+      return;
+    }
 
-      // update selection set
+    if (Input.getType(selection) === Input.Type.SINGLESELECTION) {
+      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedItemIndex);
     }
   }
 
-  /**
- * Initialise commands
- * @param {string} command
- */
-  initialiseItem(command) {
-    DesignCore.Scene.saveRequired();
-    DesignCore.CommandLine.addToCommandHistory(command);
-    this.activeCommand = DesignCore.CommandManager.createNew(command);
-  };
-
   /**
    * Set the command prompt
    * @param {string} prompt
    */
   setPrompt(prompt) {
-    // TODO: single line method required?
-    DesignCore.CommandLine.setPrompt(`${this.activeCommand.type} - ${prompt}`);
+    // return if there is no active command
+    if (this.activeCommand === undefined) {
+      return;
+    }
+
+    DesignCore.CommandLine.setPrompt(`${this.activeCommand.type}${prompt ? '- ':''}${prompt}`);
   }
 
   /**
    * Execute the currently active command then reset
-   * @param {*} item - item to create
-   * @param {*} index - index of item in scene.items
+   * @param {Object} item - item to create
+   * @param {number} index - index of item
    */
   executeCommand(item, index = undefined) {
     this.actionCommand(item, index);
@@ -397,17 +399,20 @@ export class InputManager {
 
   /**
    * Execute the currently active command without reset
-   * @param {*} item - item to create
-   * @param {*} index - index of item in scene.items
+   * @param {Object} item - item to create
+   * @param {number} index - index of item
+   * @return {number}
    */
   actionCommand(item, index = undefined) {
     if (this.activeCommand instanceof Tool) {
       this.activeCommand.action();
     } else {
+      if (item !== undefined) {
       // set the items layer to the current layer
-      item.layer = DesignCore.LayerManager.getCstyle();
-      // return the item index
-      return DesignCore.Scene.addItem(item.type, item, index);
+        item.layer = DesignCore.LayerManager.getCstyle();
+        // return the item index
+        return DesignCore.Scene.addItem(item.type, item, index);
+      }
     }
   }
 }