change(web): move KeyboardProcessor.Codes into common/web/types 🏗️

common/web/input-processor/src/correctionLayout.ts

@@ -1,4 +1,5 @@
-import { ActiveKey, ActiveKeyBase, ActiveLayer, ActiveRow, Codes } from "@keymanapp/keyboard-processor";
+import { ActiveKey, ActiveKeyBase, ActiveLayer, ActiveRow } from "@keymanapp/keyboard-processor";
+import { Codes } from "@keymanapp/common-types";
 
 /**
  * Defines correction-layout mappings for keys to be considered by
@@ -108,4 +109,4 @@ export function buildCorrectiveLayout(layer: ActiveLayer, kbdScaleRatio: number)
     .filter((entry) => correctionKeyFilter(entry.keySpec)),
     kbdScaleRatio: kbdScaleRatio
   };
-}
+}

common/web/input-processor/src/text/inputProcessor.ts

@@ -6,10 +6,10 @@ import ContextWindow from "./contextWindow.js";
 import LanguageProcessor from "./prediction/languageProcessor.js";
 import type ModelSpec from "./prediction/modelSpec.js";
 import { globalObject, DeviceSpec } from "@keymanapp/web-utils";
+import { Codes } from "@keymanapp/common-types";
 
 import {
   type Alternate,
-  Codes,
   isEmptyTransform,
   type Keyboard,
   KeyboardInterface,
@@ -385,4 +385,4 @@ export default class InputProcessor {
     // With the layer now set, we trigger new predictions.
     this.languageProcessor.invalidateContext(outputTarget, this.keyboardProcessor.layerId);
   }
-}
+}

common/web/keyboard-processor/src/index.ts

@@ -24,8 +24,6 @@ export {
 export { default as SpacebarText } from "./keyboards/spacebarText.js";
 export { default as StateKeyMap } from "./keyboards/stateKeyMap.js";
 
-export { default as Codes } from "./text/codes.js";
-export * from "./text/codes.js";
 export * from "./text/deadkeys.js";
 export { default as DefaultRules } from "./text/defaultRules.js";
 export * from "./text/defaultRules.js";

common/web/keyboard-processor/src/keyboards/activeLayout.ts

@@ -1,4 +1,4 @@
-import Codes from "../text/codes.js";
+import { Codes } from '@keymanapp/common-types';
 import KeyEvent, { KeyEventSpec } from "../text/keyEvent.js";
 import KeyMapping from "../text/keyMapping.js";
 import { ButtonClasses, Layouts } from "./defaultLayouts.js";

common/web/keyboard-processor/src/keyboards/defaultLayouts.ts

@@ -4,7 +4,7 @@
 ***/
 
 import { Version, deepCopy } from "@keymanapp/web-utils";
-import { TouchLayout } from "@keymanapp/common-types";
+import { Codes, TouchLayout } from "@keymanapp/common-types";
 
 import LayoutFormFactorSpec = TouchLayout.TouchLayoutPlatform;
 import LayoutLayerBase = TouchLayout.TouchLayoutLayer;
@@ -16,7 +16,6 @@ import ButtonClasses = TouchLayout.TouchLayoutKeySp;
 
 export { ButtonClasses };
 
-import Codes from "../text/codes.js";
 import type Keyboard from "./keyboard.js";
 
 export interface EncodedVisualKeyboard {

common/web/keyboard-processor/src/keyboards/keyboard.ts

@@ -1,4 +1,4 @@
-import Codes from "../text/codes.js";
+import { Codes } from '@keymanapp/common-types';
 import { EncodedVisualKeyboard, LayoutSpec, Layouts } from "./defaultLayouts.js";
 import { ActiveKey, ActiveLayout, ActiveSubKey } from "./activeLayout.js";
 import KeyEvent from "../text/keyEvent.js";

common/web/keyboard-processor/src/keyboards/keyboardHarness.ts

@@ -1,5 +1,5 @@
+import { Codes } from '@keymanapp/common-types';
 import Keyboard from "./keyboard.js";
-import Codes from "../text/codes.js";
 
 /**
  * Defines members of the top-level `keyman` global object necessary to guarantee

common/web/keyboard-processor/src/text/defaultRules.ts

@@ -2,7 +2,7 @@
 // We should start splitting off code needed by keyboards even without a KeyboardProcessor active.
 // There's an upcoming `/common/web/types` package that 'codes' and 'keyboards' may fit well within.
 
-import Codes from "./codes.js";
+import { Codes } from '@keymanapp/common-types';
 import type KeyEvent from "./keyEvent.js";
 import type OutputTarget from "./outputTarget.js";
 

common/web/keyboard-processor/src/text/kbdInterface.ts

@@ -6,8 +6,8 @@
 //#region Imports
 
 import { type DeviceSpec } from "@keymanapp/web-utils";
+import { Codes } from '@keymanapp/common-types';
 
-import Codes from "./codes.js";
 import type KeyEvent from "./keyEvent.js";
 import type { Deadkey } from "./deadkeys.js";
 import KeyMapping from "./keyMapping.js";

common/web/keyboard-processor/src/text/keyEvent.ts

@@ -8,8 +8,8 @@
 
 import type Keyboard from "../keyboards/keyboard.js";
 import { type DeviceSpec } from "@keymanapp/web-utils";
+import { Codes } from '@keymanapp/common-types';
 
-import Codes from './codes.js';
 import DefaultRules from './defaultRules.js';
 import { ActiveKeyBase } from "../index.js";
 

common/web/keyboard-processor/src/text/keyboardProcessor.ts

@@ -1,8 +1,8 @@
 // #region Big ol' list of imports
 
 import { EventEmitter } from 'eventemitter3';
+import { Codes } from '@keymanapp/common-types';
 
-import Codes from "./codes.js";
 import type Keyboard from "../keyboards/keyboard.js";
 import { MinimalKeymanGlobal } from '../keyboards/keyboardHarness.js';
 import KeyEvent from "./keyEvent.js";

common/web/keyboard-processor/tests/node/chirality.js

@@ -4,7 +4,8 @@ import fs from 'fs';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
-import { Codes, KeyboardInterface, MinimalKeymanGlobal } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
+import { KeyboardInterface, MinimalKeymanGlobal } from '@keymanapp/keyboard-processor';
 import { NodeKeyboardLoader } from '@keymanapp/keyboard-processor/node-keyboard-loader';
 import { KeyboardTest, NodeProctor } from '@keymanapp/recorder-core';
 
@@ -249,4 +250,4 @@ describe('Engine - Chirality', function() {
       assert.equal(modifierTarget, mappedModifiers);
     });
   });
-});
+});

common/web/keyboard-processor/tests/node/non-positional-rules.js

@@ -4,7 +4,8 @@ import fs from 'fs';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
-import { Codes, KeyboardInterface, KeyEvent, MinimalKeymanGlobal, Mock } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
+import { KeyboardInterface, KeyEvent, MinimalKeymanGlobal, Mock } from '@keymanapp/keyboard-processor';
 import { NodeKeyboardLoader } from '@keymanapp/keyboard-processor/node-keyboard-loader';
 
 // Compare and contrast the unit tests here with those for app/browser key-event unit testing
@@ -195,4 +196,4 @@ describe('Engine - rule processing', function() {
       assert.isTrue(positionalResult.triggerKeyDefault);
     });
   });
-});
+});

common/web/keyboard-processor/tests/node/specialized-backspace.js

@@ -4,7 +4,8 @@ import fs from 'fs';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
-import { Codes, KeyboardInterface, KeyboardProcessor, KeyEvent, MinimalKeymanGlobal, Mock } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
+import { KeyboardInterface, KeyboardProcessor, KeyEvent, MinimalKeymanGlobal, Mock } from '@keymanapp/keyboard-processor';
 import { NodeKeyboardLoader } from '@keymanapp/keyboard-processor/node-keyboard-loader';
 
 
@@ -346,4 +347,4 @@ describe('Engine - specialized backspace handling', function() {
     assert.equal(transform.deleteLeft, 0);
     assert.isNotOk(transform.deleteRight);
   });
-});
+});

common/web/keyboard-processor/src/text/codes.ts → common/web/types/src/consts/codes.ts

@@ -1,9 +1,8 @@
-// TODO:  Move to separate folder:  'codes'
 // We should start splitting off code needed by keyboards even without a KeyboardProcessor active.
 
 // see also: common/web/types/src/kmx/kmx.ts
 
-const Codes = {
+export const Codes = {
   // Define Keyman Developer modifier bit-flags (exposed for use by other modules)
   // Compare against /common/include/kmx_file.h.  CTRL+F "#define LCTRLFLAG" to find the secton.
   modifierCodes: {
@@ -115,13 +114,13 @@ const Codes = {
    * @return      {number}                    modifier key state (desktop keyboards)
    */
    getModifierState(layerId: string): number {
-    var modifier=0;
+    let modifier=0;
     if(layerId.indexOf('shift') >= 0) {
       modifier |= Codes.modifierCodes['SHIFT'];
     }
 
     // The chiral checks must not be directly exclusive due each other to visual OSK feedback.
-    var ctrlMatched=false;
+    let ctrlMatched=false;
     if(layerId.indexOf('leftctrl') >= 0) {
       modifier |= Codes.modifierCodes['LCTRL'];
       ctrlMatched=true;
@@ -134,7 +133,7 @@ const Codes = {
       modifier |= Codes.modifierCodes['CTRL'];
     }
 
-    var altMatched=false;
+    let altMatched=false;
     if(layerId.indexOf('leftalt') >= 0) {
       modifier |= Codes.modifierCodes['LALT'];
       altMatched=true;
@@ -157,7 +156,7 @@ const Codes = {
    * @return      {number}                    modifier key state (desktop keyboards)
    */
   getStateFromLayer(layerId: string): number {
-    var modifier=0;
+    let modifier=0;
 
     if(layerId.indexOf('caps') >= 0) {
       modifier |= Codes.modifierCodes['CAPS'];
@@ -168,5 +167,3 @@ const Codes = {
     return modifier;
   }
 }
-
-export default Codes;

common/web/types/src/main.ts

@@ -19,6 +19,7 @@ export { UnicodeSetParser, UnicodeSet } from './ldml-keyboard/unicodeset-parser-
 export { VariableParser, MarkerParser } from './ldml-keyboard/pattern-parser.js';
 export { LDMLKeyboardXMLSourceFileReader, LDMLKeyboardXMLSourceFileReaderOptions } from './ldml-keyboard/ldml-keyboard-xml-reader.js';
 
+export { Codes } from './consts/codes.js';
 export * as Constants from './consts/virtual-key-constants.js';
 
 export { defaultCompilerOptions, CompilerBaseOptions, CompilerCallbacks, CompilerOptions, CompilerEvent, CompilerErrorNamespace,

common/web/types/test/types/consts/test-codes.ts

@@ -0,0 +1,71 @@
+import 'mocha';
+import { assert } from 'chai';
+import { Codes } from '../../../src/consts/codes.js';
+
+describe('Codes', function () {
+  describe('test isFrameKey()', function () {
+    it('should properly identify frame keys', () => {
+      [
+        'K_SHIFT',
+        'K_LOPT',
+        'K_ROPT',
+        'K_NUMLOCK',
+        'K_CAPS',
+        'K_NUMERALS', // not explicitly listed, but included because > 50000
+      ].forEach(keyId => assert.isTrue(Codes.isFrameKey(keyId), `isFrameKey(${keyId})`));
+
+      [
+        'K_ESC',
+        'K_OE2',
+        'K_ALT',  // not currently included in isFrameKey
+        'K_CTRL', // not currently included in isFrameKey
+      ].forEach(keyId => assert.isFalse(Codes.isFrameKey(keyId), `!isFrameKey(${keyId})`));
+    });
+  });
+
+  describe('test getModifierState()', function () {
+    it('should properly identify modifiers from layer id', () => {
+      [
+        { layerId: 'shift', expected: Codes.modifierCodes['SHIFT'] },
+        { layerId: 'leftshift', expected: Codes.modifierCodes['SHIFT'] },
+        { layerId: 'rightshift', expected: Codes.modifierCodes['SHIFT'] },
+        { layerId: 'ctrlshift', expected: Codes.modifierCodes['CTRL'] | Codes.modifierCodes['SHIFT'] },
+        { layerId: 'shiftctrl', expected: Codes.modifierCodes['CTRL'] | Codes.modifierCodes['SHIFT'] },
+        { layerId: 'fooshift', expected: Codes.modifierCodes['SHIFT'] },
+
+        { layerId: 'leftctrl', expected: Codes.modifierCodes['LCTRL'] },
+        { layerId: 'rightctrl', expected: Codes.modifierCodes['RCTRL'] },
+        { layerId: 'ctrl', expected: Codes.modifierCodes['CTRL'] },
+        { layerId: 'right_ctrl', expected: Codes.modifierCodes['CTRL'] },
+        { layerId: 'leftctrlrightctrlshift', expected: Codes.modifierCodes['LCTRL'] | Codes.modifierCodes['RCTRL'] | Codes.modifierCodes['SHIFT'] },
+        { layerId: 'leftctrl-rightctrl-shift', expected: Codes.modifierCodes['LCTRL'] | Codes.modifierCodes['RCTRL'] | Codes.modifierCodes['SHIFT'] },
+        { layerId: 'ctrl-rightctrl-shift', expected: Codes.modifierCodes['RCTRL'] | Codes.modifierCodes['SHIFT'] },
+
+        { layerId: 'leftalt', expected: Codes.modifierCodes['LALT'] },
+        { layerId: 'rightalt', expected: Codes.modifierCodes['RALT'] },
+        { layerId: 'alt', expected: Codes.modifierCodes['ALT'] },
+        { layerId: 'leftaltrightaltshift', expected: Codes.modifierCodes['LALT'] | Codes.modifierCodes['RALT'] | Codes.modifierCodes['SHIFT'] },
+        { layerId: 'leftaltrightalt', expected: Codes.modifierCodes['LALT'] | Codes.modifierCodes['RALT'] },
+        { layerId: 'shiftleftctrlrightctrlleftaltrightalt', expected: Codes.modifierCodes['LCTRL'] | Codes.modifierCodes['RCTRL'] | Codes.modifierCodes['SHIFT'] | Codes.modifierCodes['LALT'] | Codes.modifierCodes['RALT'] },
+        { layerId: 'shiftctrlalt', expected: Codes.modifierCodes['SHIFT'] | Codes.modifierCodes['CTRL'] | Codes.modifierCodes['ALT'] },
+
+        { layerId: 'foo', expected: 0 },
+
+      ].forEach(testdata => assert.equal(Codes.getModifierState(testdata.layerId), testdata.expected, `getModifierState(${testdata.layerId})`));
+    });
+  });
+
+  describe('test getStateFromLayer()', function () {
+    it('should properly identify caps state from layer id', () => {
+      [
+        { layerId: 'caps', expected: Codes.modifierCodes['CAPS'] },
+        { layerId: 'altcaps', expected: Codes.modifierCodes['CAPS'] },
+        { layerId: 'capsalt', expected: Codes.modifierCodes['CAPS'] },
+
+        { layerId: 'shift', expected: Codes.modifierCodes['NO_CAPS'] },
+        { layerId: 'foo', expected: Codes.modifierCodes['NO_CAPS'] },
+
+      ].forEach(testdata => { assert.equal(Codes.getStateFromLayer(testdata.layerId), testdata.expected, `getStateFromLayer(${testdata.layerId})`); });
+    });
+  });
+});

web/src/app/browser/src/defaultBrowserRules.ts

@@ -1,5 +1,5 @@
+import { Codes } from "@keymanapp/common-types";
 import {
-  Codes,
   DefaultRules,
   type KeyEvent,
   type OutputTarget

web/src/app/browser/src/hardwareEventKeyboard.ts

@@ -1,4 +1,5 @@
-import { Codes, DeviceSpec, KeyEvent, KeyMapping, Keyboard, KeyboardProcessor } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
+import { DeviceSpec, KeyEvent, KeyMapping, Keyboard, KeyboardProcessor } from '@keymanapp/keyboard-processor';
 
 import { HardKeyboard, processForMnemonicsAndLegacy } from 'keyman/engine/main';
 import { DomEventTracker } from 'keyman/engine/events';

web/src/engine/main/src/hardKeyboard.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "eventemitter3";
-import { Keyboard, KeyMapping, KeyEvent, type RuleBehavior, Codes } from "@keymanapp/keyboard-processor";
+import { Keyboard, KeyMapping, KeyEvent, type RuleBehavior } from "@keymanapp/keyboard-processor";
+import { Codes } from "@keymanapp/common-types";
 import { KeyEventSourceInterface } from 'keyman/engine/events';
 
 interface EventMap {

web/src/engine/osk/src/index.ts

@@ -1,4 +1,4 @@
-export { Codes, DeviceSpec, Keyboard, KeyboardProperties, SpacebarText } from '@keymanapp/keyboard-processor';
+export { DeviceSpec, Keyboard, KeyboardProperties, SpacebarText } from '@keymanapp/keyboard-processor';
 
 export { default as OSKView } from './views/oskView.js';
 export { default as FloatingOSKView, FloatingOSKViewConfiguration } from './views/floatingOskView.js';

web/src/engine/osk/src/keyboard-layout/oskBaseKey.ts

@@ -1,4 +1,5 @@
-import { ActiveKey, Codes } from '@keymanapp/keyboard-processor';
+import { ActiveKey } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
 
 import OSKKey, { KeyLayoutParams, renameSpecialKey } from './oskKey.js';
 import { KeyData, KeyElement, link } from '../keyElement.js';

web/src/engine/osk/src/views/oskView.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
+import { Codes } from "@keymanapp/common-types";
 
 import { BannerView } from '../banner/bannerView.js';
 import { BannerController } from '../banner/bannerController.js';
@@ -11,7 +12,6 @@ import { LengthStyle, ParsedLengthStyle } from '../lengthStyle.js';
 import { type KeyElement } from '../keyElement.js';
 
 import {
-  Codes,
   DeviceSpec,
   Keyboard,
   KeyboardProperties,

web/src/test/auto/headless/app/browser/hardware-event-processing.tests.ts

@@ -4,7 +4,8 @@ import { preprocessKeyboardEvent } from 'keyman/app/browser';
 import { processForMnemonicsAndLegacy } from 'keyman/engine/main';
 import { PhysicalInputEventSpec } from '@keymanapp/recorder-core';
 import { DeviceSpec } from '@keymanapp/web-utils';
-import { Codes, Keyboard, KeyEvent } from '@keymanapp/keyboard-processor';
+import { Codes } from "@keymanapp/common-types";
+import { Keyboard, KeyEvent } from '@keymanapp/keyboard-processor';
 
 const ModifierCodes = Codes.modifierCodes;
 const KeyCodes = Codes.keyCodes;