@keymanapp/common-types 17.0.85-alpha

package/src/kmx/kmx-plus-builder/build-tran.ts

@@ -0,0 +1,50 @@
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { Bksp, Finl, Tran } from "../kmx-plus.js";
+import { build_elem_index, BUILDER_ELEM } from "./build-elem.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+* tran section
+  ------------------------------------------------------------------ */
+
+interface BUILDER_TRAN_ITEM {
+  from: number; //elem.string
+  to: number; //str
+  before: number; //elem.string
+  flags: number;
+};
+
+export interface BUILDER_TRAN extends BUILDER_SECTION {
+ count: number;
+ items: BUILDER_TRAN_ITEM[];
+};
+
+/**
+* Builder for the 'tran', 'finl', and 'bksp' sections, all of which use the BUILDER_TRAN layout
+*/
+export function build_tran(source_tran: Tran|Finl|Bksp, sect_strs: BUILDER_STRS, sect_elem: BUILDER_ELEM): BUILDER_TRAN {
+ if(!source_tran?.items.length) {
+   return null;
+ }
+
+ let tran: BUILDER_TRAN = {
+   ident: constants.hex_section_id(source_tran.id),
+   size: constants.length_tran + constants.length_tran_item * source_tran.items.length,
+   _offset: 0,
+   count: source_tran.items.length,
+   items: []
+ };
+
+ for(let item of source_tran.items) {
+   tran.items.push({
+    from: build_elem_index(sect_elem, item.from),
+    to: build_strs_index(sect_strs, item.to),
+    before: build_elem_index(sect_elem, item.before),
+    flags: item.flags
+   });
+ }
+
+ return tran;
+}

package/src/kmx/kmx-plus-builder/build-vkey.ts

@@ -0,0 +1,43 @@
+import { constants } from '@keymanapp/ldml-keyboard-constants';
+import { KMXPlusData } from "../kmx-plus.js";
+import { BUILDER_SECTION } from './builder-section.js';
+
+/* ------------------------------------------------------------------
+ * vkey section
+   ------------------------------------------------------------------ */
+
+/**
+ * Builder for the 'vkey' section
+ */
+interface BUILDER_VKEY_ITEM {
+  vkey: number;
+  target: number;
+};
+
+export interface BUILDER_VKEY extends BUILDER_SECTION {
+  count: number;
+  items: BUILDER_VKEY_ITEM[];
+};
+
+export function build_vkey(kmxplus: KMXPlusData): BUILDER_VKEY {
+  if(!kmxplus.vkey.vkeys.length) {
+    return null;
+  }
+
+  let vkey: BUILDER_VKEY = {
+    ident: constants.hex_section_id(constants.section.vkey),
+    size: constants.length_vkey + constants.length_vkey_item * kmxplus.vkey.vkeys.length,
+    _offset: 0,
+    count: kmxplus.vkey.vkeys.length,
+    items: []
+  };
+
+  for(let item of kmxplus.vkey.vkeys) {
+    vkey.items.push({
+      vkey: item.vkey,
+      target: item.target
+    });
+  }
+
+  return vkey;
+}

package/src/kmx/kmx-plus-builder/builder-section.ts

@@ -0,0 +1,6 @@
+export interface BUILDER_SECTION {
+  ident: number;
+  size: number;
+  _offset: number; // used only for building the output
+}
+;

package/src/kmx/kmx-plus-builder/kmx-plus-builder.ts

@@ -0,0 +1,190 @@
+import * as r from 'restructure';
+import { KMXPlusFile } from "../kmx-plus.js";
+import { constants, SectionIdent } from '@keymanapp/ldml-keyboard-constants';
+import { BUILDER_SECTION } from './builder-section.js';
+import { BUILDER_SECT, build_sect } from './build-sect.js';
+import { BUILDER_DISP, build_disp } from './build-disp.js';
+import { BUILDER_ELEM, build_elem } from './build-elem.js';
+import { BUILDER_KEYS, build_keys } from './build-keys.js';
+import { BUILDER_LAYR, build_layr } from './build-layr.js';
+import { BUILDER_LIST, build_list } from './build-list.js';
+import { BUILDER_LOCA, build_loca } from './build-loca.js';
+import { BUILDER_META, build_meta } from './build-meta.js';
+import { BUILDER_NAME, build_name } from './build-name.js';
+import { BUILDER_ORDR, build_ordr } from './build-ordr.js';
+import { BUILDER_STRS, build_strs } from './build-strs.js';
+import { BUILDER_TRAN, build_tran } from './build-tran.js';
+import { BUILDER_VKEY, build_vkey } from './build-vkey.js';
+
+type BUILDER_BKSP = BUILDER_TRAN;
+type BUILDER_FINL = BUILDER_TRAN;
+
+type SectionBuilders = {
+  // [id in SectionIdent]: BUILDER_SECTION;
+  sect?: BUILDER_SECT;
+  bksp?: BUILDER_BKSP;
+  disp?: BUILDER_DISP;
+  elem?: BUILDER_ELEM;
+  finl?: BUILDER_FINL;
+  keys?: BUILDER_KEYS;
+  layr?: BUILDER_LAYR;
+  list?: BUILDER_LIST;
+  loca?: BUILDER_LOCA;
+  meta?: BUILDER_META;
+  name?: BUILDER_NAME;
+  ordr?: BUILDER_ORDR;
+  strs?: BUILDER_STRS;
+  tran?: BUILDER_TRAN;
+  vkey?: BUILDER_VKEY;
+};
+
+export default class KMXPlusBuilder {
+  private file: KMXPlusFile;
+  //private writeDebug: boolean;
+
+  sect : SectionBuilders = {
+
+  };
+
+  constructor(file: KMXPlusFile, _writeDebug: boolean) {
+    this.file = file;
+    //this.writeDebug = _writeDebug;
+  }
+
+  public compile(): Uint8Array {
+    const fileSize = this.build();
+    let file: Uint8Array = new Uint8Array(fileSize);
+
+    this.emitSection(file, this.file.COMP_PLUS_SECT, this.sect.sect);
+    // Keep the rest of these in order.
+    this.emitSection(file, this.file.COMP_PLUS_BKSP, this.sect.bksp);
+    this.emitSection(file, this.file.COMP_PLUS_DISP, this.sect.disp);
+    this.emitSection(file, this.file.COMP_PLUS_ELEM, this.sect.elem);
+    this.emitElements(file);
+    this.emitSection(file, this.file.COMP_PLUS_FINL, this.sect.finl);
+    this.emitSection(file, this.file.COMP_PLUS_KEYS, this.sect.keys);
+    this.emitSection(file, this.file.COMP_PLUS_LAYR, this.sect.layr);
+    this.emitSection(file, this.file.COMP_PLUS_LIST, this.sect.list);
+    this.emitSection(file, this.file.COMP_PLUS_LOCA, this.sect.loca);
+    this.emitSection(file, this.file.COMP_PLUS_META, this.sect.meta);
+    this.emitSection(file, this.file.COMP_PLUS_NAME, this.sect.name);
+    this.emitSection(file, this.file.COMP_PLUS_ORDR, this.sect.ordr);
+    this.emitSection(file, this.file.COMP_PLUS_STRS, this.sect.strs);
+    this.emitStrings(file);
+    this.emitSection(file, this.file.COMP_PLUS_TRAN, this.sect.tran);
+    this.emitSection(file, this.file.COMP_PLUS_VKEY, this.sect.vkey);
+
+    return file;
+  }
+
+  private build() {
+    // Required sections: sect, strs, loca, meta
+
+    // We must prepare the strs, list, and elem sections early so that other sections can
+    // reference them. However, they will be emitted in alpha order.
+    this.sect.strs = build_strs(this.file.kmxplus.strs);
+    this.sect.list = build_list(this.file.kmxplus.list, this.sect.strs);
+    this.sect.elem = build_elem(this.file.kmxplus.elem, this.sect.strs);
+
+    const build_bksp = build_tran;
+    const build_finl = build_tran;
+
+    this.sect.bksp = build_bksp(this.file.kmxplus.bksp, this.sect.strs, this.sect.elem);
+    this.sect.disp = build_disp(this.file.kmxplus, this.sect.strs);
+    this.sect.finl = build_finl(this.file.kmxplus.finl, this.sect.strs, this.sect.elem);
+    this.sect.keys = build_keys(this.file.kmxplus, this.sect.strs, this.sect.list);
+    this.sect.layr = build_layr(this.file.kmxplus, this.sect.strs, this.sect.list);
+    this.sect.loca = build_loca(this.file.kmxplus, this.sect.strs);
+    this.sect.meta = build_meta(this.file.kmxplus, this.sect.strs);
+    this.sect.name = build_name(this.file.kmxplus, this.sect.strs);
+    this.sect.ordr = build_ordr(this.file.kmxplus, this.sect.strs, this.sect.elem);
+    this.sect.tran = build_tran(this.file.kmxplus.tran, this.sect.strs, this.sect.elem);
+    this.sect.vkey = build_vkey(this.file.kmxplus);
+
+    // Finalize the sect (index) section
+
+    this.sect.sect = build_sect();
+    this.finalize_sect(); // must be done last
+    return this.sect.sect.total;
+  }
+
+  private finalize_sect() {
+    // 'sect' section
+
+    this.sect.sect.count = 0;
+
+    Object.keys(constants.section).forEach((sectstr : string) => {
+      const sect : SectionIdent = constants.section[<SectionIdent>sectstr];
+      if(this.sect[sect] && sect !== 'sect') {
+        this.sect.sect.count++;
+      }
+    });
+
+    this.sect.sect.size = constants.length_sect + constants.length_sect_item * this.sect.sect.count;
+
+    let offset = this.sect.sect.size;
+    // Note: in order! Everyone's here except 'sect' which is at offset 0
+    offset = this.finalize_sect_item(this.sect.bksp, offset);
+    offset = this.finalize_sect_item(this.sect.disp, offset);
+    offset = this.finalize_sect_item(this.sect.elem, offset);
+    offset = this.finalize_sect_item(this.sect.finl, offset);
+    offset = this.finalize_sect_item(this.sect.keys, offset);
+    offset = this.finalize_sect_item(this.sect.layr, offset);
+    offset = this.finalize_sect_item(this.sect.list, offset);
+    offset = this.finalize_sect_item(this.sect.loca, offset);
+    offset = this.finalize_sect_item(this.sect.meta, offset);
+    offset = this.finalize_sect_item(this.sect.name, offset);
+    offset = this.finalize_sect_item(this.sect.ordr, offset);
+    offset = this.finalize_sect_item(this.sect.strs, offset);
+    offset = this.finalize_sect_item(this.sect.tran, offset);
+    offset = this.finalize_sect_item(this.sect.vkey, offset);
+
+    this.sect.sect.total = offset;
+  }
+
+  private finalize_sect_item(sect: BUILDER_SECTION, offset: number): number {
+    if(!sect) {
+      // Don't include null sections
+      return offset;
+    }
+    sect._offset = offset;
+    this.sect.sect.items.push({sect: sect.ident, offset: offset});
+    return offset + sect.size;
+  }
+
+  private emitSection(file: Uint8Array, comp: any, sect: BUILDER_SECTION) {
+    if(sect) {
+      const buf = comp.toBuffer(sect);
+      if (buf.length > sect.size) {
+        // buf.length may be < sect.size if there is a variable part (i.e. elem)
+        throw new RangeError(`Internal Error: Section ${constants.str_section_id(sect.ident)} claimed size ${sect.size} but produced buffer of size ${buf.length}.`);
+      }
+      file.set(buf, sect._offset);
+    }
+  }
+
+  private emitStrings(file: Uint8Array) {
+    for(let item of this.sect.strs.items) {
+      if(item._value === '') {
+        // We have a special case for the zero-length string
+        let sbuf = r.uint16le;
+        file.set(sbuf.toBuffer(0), item.offset + this.sect.strs._offset);
+      } else {
+        let sbuf = new r.String(null, 'utf16le');
+        file.set(sbuf.toBuffer(item._value), item.offset + this.sect.strs._offset);
+      }
+    }
+  }
+
+  private emitElements(file: Uint8Array) {
+    if(this.sect.elem) {
+      for(let str of this.sect.elem.strings) {
+        if(str.items.length > 0) {
+          let COMP_PLUS_ELEM_ELEMENTS = new r.Array(this.file.COMP_PLUS_ELEM_ELEMENT, str.items.length);
+          file.set(COMP_PLUS_ELEM_ELEMENTS.toBuffer(str.items), str.offset + this.sect.elem._offset);
+        }
+      }
+    }
+  }
+
+}