@keymanapp/kmc-kmn 17.0.85-alpha

package/src/compiler/compiler.ts

@@ -0,0 +1,93 @@
+/*
+TODO: implement additional interfaces:
+
+  extern "C" bool kmcmp_CompileKeyboardFileToBuffer(
+    char* pszInfile,
+    void* pfkBuffer,
+    bool ACompilerWarningsAsErrors,
+    bool AWarnDeprecatedCode,
+    kmcmp_CompilerMessageProc pMsgproc,
+    void* AmsgprocContext,
+    int Target
+  );
+
+  typedef bool (*kmcmp_ValidateJsonMessageProc)(int64_t offset, const char* szText, void* context);
+
+  extern "C" bool kmcmp_ValidateJsonFile(
+    std::fstream& f,
+    std::fstream& fd,
+    kmcmp_ValidateJsonMessageProc MessageProc,
+    void* context
+  );
+*/
+
+// TODO: rename wasm-host?
+import loadWasmHost from '../import/kmcmplib/wasm-host.js';
+
+export interface CompilerOptions {
+  shouldAddCompilerVersion?: boolean;
+  saveDebug?: boolean;
+  compilerWarningsAsErrors?: boolean;
+	warnDeprecatedCode?: boolean;
+};
+
+const baseOptions: CompilerOptions = {
+  shouldAddCompilerVersion: true,
+  saveDebug: true,
+  compilerWarningsAsErrors: false,
+  warnDeprecatedCode: true
+};
+
+export class Compiler {
+  wasmModule: any;
+  compileKeyboardFile: any;
+  setCompilerOptions: any;
+
+  public async init(): Promise<boolean> {
+    if(!this.wasmModule) {
+      this.wasmModule = await loadWasmHost();
+      this.compileKeyboardFile = this.wasmModule.cwrap('kmcmp_Wasm_CompileKeyboardFile', 'number', ['string', 'string',
+        'number', 'number', 'number', 'string']);
+      this.setCompilerOptions = this.wasmModule.cwrap('kmcmp_Wasm_SetCompilerOptions', 'number', ['number']);
+    }
+    return this.compileKeyboardFile !== undefined && this.setCompilerOptions !== undefined;
+  }
+
+  public run(infile: string, outfile: string, options?: CompilerOptions): boolean {
+    if(!this.wasmModule) {
+      return false;
+    }
+
+    options = {...baseOptions, ...options};
+
+    (globalThis as any).msgproc = function(line: number, code: number, msg: string) {
+      // TODO: link into the kmc error reporting infrastructure
+      console.log(`[${line}] ${code}: ${msg}`);
+    }
+
+    // TODO: use callbacks for file access -- so kmc-kmn is entirely fs agnostic
+    let result = this.runCompiler(infile, outfile, options) == 1;
+
+    (globalThis as any).msgproc = null;
+
+    return result;
+  }
+
+  private runCompiler(infile: string, outfile: string, options: CompilerOptions): number {
+    try {
+      if(!this.setCompilerOptions(options.shouldAddCompilerVersion)) {
+        console.error('Unable to set compiler options');
+      }
+      return this.compileKeyboardFile(
+        infile,
+        outfile,
+        options.saveDebug ? 1 : 0,
+        options.compilerWarningsAsErrors ? 1 : 0,
+        options.warnDeprecatedCode ? 1 : 0, 'msgproc');
+    } catch(e) {
+      // TODO: use sentry
+      console.error(e);
+    }
+    return 0;
+  }
+}

package/src/main.ts

@@ -0,0 +1,2 @@
+
+export { Compiler } from './compiler/compiler.js';

package/test/README.md

@@ -0,0 +1,7 @@
+Keyman kmn Keyboard Compiler Tests
+===================================
+
+Test
+----
+
+    ../build.sh test

package/test/fixtures/000.kmn

@@ -0,0 +1,11 @@
+c Description: Tests null keyboard 
+c keys: [K_A][RALT K_B][SHIFT K_C]
+c expected: aC
+c context: 
+
+store(&version) '6.0'
+
+begin Unicode > use(Main)
+
+group(Main) using keys
+         

package/test/test-compiler.ts

@@ -0,0 +1,47 @@
+import 'mocha';
+import sinon from 'sinon';
+// import chai, { expect } from 'chai';
+import chai, { assert } from 'chai';
+import sinonChai from 'sinon-chai';
+import { Compiler } from '../src/main.js';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url)).replace(/\\/g, '/');
+
+chai.use(sinonChai);
+
+describe('Compiler class', function() {
+  let consoleLog: any;
+
+  beforeEach(function() {
+    consoleLog = sinon.spy(console, 'log');
+  });
+
+  afterEach(function() {
+    consoleLog.restore();
+  });
+
+  it('should start', async function() {
+    const compiler = new Compiler();
+    assert(await compiler.init());
+  });
+
+  it('should compile a basic keyboard', async function() {
+    const compiler = new Compiler();
+    assert(await compiler.init());
+
+    const fixtureName = __dirname + '/../../test/fixtures/000.kmx';
+    const infile = __dirname + '/../../test/fixtures/000.kmn';
+    const outfile = __dirname + '/000.kmx';
+
+    assert(compiler.run(infile, outfile, {saveDebug: true, shouldAddCompilerVersion: false}));
+
+    assert(fs.existsSync(outfile));
+    const outfileData = fs.readFileSync(outfile);
+    const fixtureData = fs.readFileSync(fixtureName);
+    assert.equal(outfileData.byteLength, fixtureData.byteLength);
+    assert.deepEqual(outfileData, fixtureData);
+  });
+});

package/test/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../kmc/tsconfig.kmc-base.json",
+
+  "compilerOptions": {
+      "rootDir": ".",
+      "rootDirs": ["./", "../src/"],
+      "outDir": "../build/test",
+      "baseUrl": ".",
+      "allowSyntheticDefaultImports": true, // for chai
+      "paths": {
+        "@keymanapp/common-types": ["../../../../common/web/types/src/main"],
+      },
+    },
+  "include": [
+      "**/test-*.ts",
+      "./helpers/index.ts"
+  ],
+  "references": [
+      { "path": "../../../../common/web/keyman-version/tsconfig.esm.json" },
+      { "path": "../../../../common/web/types/" },
+      { "path": "../../../../common/tools/hextobin/" },
+      { "path": "../" }
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../../tsconfig.esm-base.json",
+
+  "compilerOptions": {
+    "outDir": "build/src/",
+    "rootDir": "src/",
+    "baseUrl": ".",
+    "allowJs": true,
+    "paths": {
+      "@keymanapp/common-types": ["../../../common/web/types/src/main"],
+    },
+
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/import/kmcmplib/wasm-host.js"
+  ],
+  "references": [
+    { "path": "../../../common/web/keyman-version/tsconfig.esm.json" },
+    { "path": "../../../common/web/types/" },
+  ]
+}