@keymanapp/common-types 17.0.85-alpha

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

@@ -0,0 +1,175 @@
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KeysFlick, KMXPlusData, StrsItem } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { build_list_index, BUILDER_LIST } from "./build-list.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+ * keys section
+   ------------------------------------------------------------------ */
+
+/**
+ * This struct is a single <key> in the keys keybag
+ */
+interface BUILDER_KEYS_KEY {
+  to: number; // str or single codepoint
+  flags: number;
+  id: number; // str with original key id
+  _id: string; // original key id, for sorting
+  switch: number; // str with layer of new l
+  width: number; // ceil((width||1)*10), so 12 for width 1.2
+  longPress: number; // list of longPress sequences
+  longPressDefault: number; // str with the default longPress target
+  multiTap: number; // list of multiTap sequences
+  flicks: number; // index into the flicks[] subtable for this flick list
+};
+
+/**
+ * This is a <flicks>, a list of <flick> elements.
+ */
+interface BUILDER_KEYS_FLICKS {
+  count: number; // number of BUILDER_KEYS_FLICK entries in this flick list
+  flick: number; // index into the flick[] subtable of the first flick in the list
+  id: number; // str with the original id of this flicks
+  _id: string; // copy of the flicks id, used for sorting during build
+  _flicks: KeysFlick[]; // temporary copy of KeysFlick object
+};
+
+/**
+ * This is a single <flick> element.
+ */
+interface BUILDER_KEYS_FLICK {
+  directions: number; // list of cardinal/intercardinal directions
+  flags: number; //
+  to: number; // str or single codepoint
+};
+
+
+interface BUILDER_KEYS_KMAP {
+  vkey: number;
+  mod: number;
+  key: number; //index to keys.key
+};
+
+/**
+ * Builder for the 'keys' section
+ */
+export interface BUILDER_KEYS extends BUILDER_SECTION {
+  ident: number;
+  size: number;
+  keyCount: number;
+  flicksCount: number;
+  flickCount: number;
+  kmapCount: number;
+  keys: BUILDER_KEYS_KEY[];
+  flicks: BUILDER_KEYS_FLICKS[];
+  flick: BUILDER_KEYS_FLICK[];
+  kmap: BUILDER_KEYS_KMAP[];
+};
+
+export function build_keys(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS, sect_list: BUILDER_LIST): BUILDER_KEYS {
+  if(kmxplus.keys.keys.length == 0 &&
+      (kmxplus.keys.flicks.length <= 1)) { // if no keys and only the 'null' flick.
+    return null;
+  }
+
+  let keys: BUILDER_KEYS = {
+    ident: constants.hex_section_id(constants.section.keys),
+    size: 0,
+    keyCount: kmxplus.keys.keys.length,
+    flicksCount: kmxplus.keys.flicks.length,
+    flickCount: 0,
+    kmapCount: kmxplus.keys.kmap.length,
+    keys: [],
+    flicks: [],
+    flick: [],
+    kmap: [],
+    _offset: 0,
+  };
+
+  // flicks first: the keys will need to index into the flicks table.
+
+  // Note that per the Keys class and spec, there is always a flicks=0 meaning 'no flicks'
+  keys.flicks = kmxplus.keys.flicks.map((flicks) => {
+    let result : BUILDER_KEYS_FLICKS = {
+      count: flicks.flicks.length,
+      flick: keys.flick.length, // index of first flick
+      id: build_strs_index(sect_strs, flicks.id),
+      _id: flicks.id.value,
+      _flicks: flicks.flicks,
+    };
+    return result;
+  });
+  // Sort the flicks array by id
+  keys.flicks.sort((a, b) => StrsItem.binaryStringCompare(a._id, b._id));
+  // now, allocate 'flick' entries for each 'flicks'
+  keys.flicks.forEach((flicks) => {
+    flicks._flicks.forEach((flick) => {
+      keys.flick.push({
+        directions: build_list_index(sect_list, flick.directions),
+        flags: flick.flags,
+        to: build_strs_index(sect_strs, flick.to),
+      });
+      keys.flickCount++;
+    });
+  });
+
+  // now, keys
+  keys.keys = kmxplus.keys.keys.map((key) => {
+    let result : BUILDER_KEYS_KEY = {
+      to: build_strs_index(sect_strs, key.to),
+      flags: key.flags,
+      id: build_strs_index(sect_strs, key.id),
+      _id: key.id.value,
+      switch: build_strs_index(sect_strs, key.switch),
+      width: key.width,
+      longPress: build_list_index(sect_list, key.longPress),
+      longPressDefault: build_strs_index(sect_strs, key.longPressDefault),
+      multiTap: build_list_index(sect_list, key.multiTap),
+      flicks: keys.flicks.findIndex(v => v._id === (key.flicks || '')), // flicks id='' is the 'null' flicks
+    };
+    // Make sure the flicks were found
+    if (result.flicks === -1) {
+      throw new Error(`Keys: Could not find flicks id=${key.flicks} for key=${key.id.value}`);
+    }
+    return result;
+  });
+  // sort the keys by id
+  keys.keys.sort((a, b) => StrsItem.binaryStringCompare(a._id, b._id));
+
+  // finally, kmap
+  keys.kmap = kmxplus.keys.kmap.map(({vkey, mod, key}) => {
+    let result : BUILDER_KEYS_KMAP = {
+      vkey,
+      mod,
+      key: keys.keys.findIndex(k => k._id === key),
+    };
+    // Make sure the key was found
+    if (result.key === -1) {
+      throw new Error(`Keys: Could not find keys.key id=${result.key} for keys.kmap.key=${key}`);
+    }
+    return result;
+  });
+
+  // Sort kmap by vkey, mod order, per C7043
+  keys.kmap.sort((a,b) => {
+    let rc = 0;
+    if (rc === 0) {
+      rc = (a.vkey - b.vkey);
+    }
+    if (rc === 0) {
+      rc = (a.mod - b.mod);
+    }
+    return rc;
+  });
+
+  let offset = constants.length_keys +
+    (constants.length_keys_key * keys.keyCount) +
+    (constants.length_keys_flick_element * keys.flickCount) +
+    (constants.length_keys_flick_list * keys.flicksCount) +
+    (constants.length_keys_kmap * keys.kmapCount);
+  keys.size = offset;
+
+  return keys;
+}

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

@@ -0,0 +1,154 @@
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlusData, LayrEntry, LayrRow, StrsItem } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_LIST } from "./build-list.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+ * layr section -
+ ------------------------------------------------------------------ */
+
+/**
+ * List of layers, the <layers> element
+ */
+interface BUILDER_LAYR_LIST {
+  hardware: number; // hardware indicator
+  layer: number; // index of first layer in the list, in the
+  count: number; // number of layer entries in the list
+  minDeviceWidth: number; // width in millimeters
+  _layers: LayrEntry[]; // original layer entry, for in-memory only
+};
+
+/**
+ * <layer> element
+ */
+interface BUILDER_LAYR_LAYER {
+  id: number; // str of layer id
+  _id: string; // original layer id, for sorting
+  mod: number; // bitfield with modifier info
+  row: number; // row index into row subtable
+  _rows: LayrRow[]; // original rows, for in-memory only
+  count: number; // number of row entries
+};
+
+/**
+ * <row> element
+ */
+interface BUILDER_LAYR_ROW {
+  key: number; // index into key subtable
+  count: number; // number of keys
+};
+
+/**
+ * portion of keys attribute of <row>
+ */
+interface BUILDER_LAYR_KEY {
+  key: number;
+};
+
+/**
+ * Builder for the 'keys' section
+ */
+export interface BUILDER_LAYR extends BUILDER_SECTION {
+  listCount: number, // number of entries in lists subtable
+  layerCount: number, // number of entries in layers subtable
+  rowCount: number, // number of entries in rows subtable
+  keyCount: number, // number of entries in keys subtable
+  lists: BUILDER_LAYR_LIST[], // subtable of <layers> elements
+  layers: BUILDER_LAYR_LAYER[], // subtable of <layer> elements
+  rows: BUILDER_LAYR_ROW[], // subtable of <row> elements
+  keys: BUILDER_LAYR_KEY[], // subtable of key entries
+};
+
+export function build_layr(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS, sect_list: BUILDER_LIST): BUILDER_LAYR {
+  if (!kmxplus.layr?.lists) {
+    return null;  // if there aren't any layers at all (which should be an invalid keyboard)
+  }
+
+  let layr: BUILDER_LAYR = {
+    ident: constants.hex_section_id(constants.section.layr),
+    size: constants.length_layr,
+    _offset: 0,
+    listCount: kmxplus.layr.lists.length,
+    layerCount: 0, // calculated below
+    rowCount: 0, // calculated below
+    keyCount: 0, // calculated below
+    lists: [],
+    layers: [],
+    rows: [],
+    keys: []
+  };
+
+  layr.lists = kmxplus.layr.lists.map((list) => {
+    const blist: BUILDER_LAYR_LIST = {
+      hardware: list.hardware,
+      layer: null, // to be set below
+      _layers: list.layers,
+      count: list.layers.length,
+      minDeviceWidth: list.minDeviceWidth,
+    };
+    return blist;
+  });
+  // now sort the lists
+  layr.lists.sort((a, b) => {
+    if (a.hardware < b.hardware) {
+      return -1;
+    } else if (a.hardware > b.hardware) {
+      return 1;
+    }
+    if (a.minDeviceWidth < b.minDeviceWidth) {
+      return -1;
+    } else if (a.minDeviceWidth > b.minDeviceWidth) {
+      return 1;
+    } else {
+      return 0; // same
+    }
+  });
+  // Now allocate the layers, rows, and keys
+  layr.lists.forEach((list) => {
+    list.layer = layr.layers.length; // index to first layer in list
+    const blayers = list._layers.map((layer) => {
+      const blayer: BUILDER_LAYR_LAYER = {
+        _id: layer.id.value, // original id
+        id: build_strs_index(sect_strs, layer.id),
+        mod: layer.mod,
+        row: null, // row ID, to be filled in
+        _rows: layer.rows, // temporary
+        count: layer.rows.length, // number of rows
+      };
+      return blayer;
+    });
+    // sort the new layers
+    blayers.sort((a, b) => StrsItem.binaryStringCompare(a._id, b._id));
+    blayers.forEach((layer) => {
+      layer.row = layr.rows.length; // index to first row in list
+      layer._rows.forEach((row) => {
+        const brow: BUILDER_LAYR_ROW = {
+          key: layr.keys.length,
+          count: row.keys.length,
+        };
+        row.keys.forEach((key) => {
+          const bkey: BUILDER_LAYR_KEY = {
+            key: build_strs_index(sect_strs, key),
+          };
+          layr.keys.push(bkey);
+        });
+        layr.rows.push(brow);
+      });
+      layr.layers.push(layer);
+    });
+  });
+
+  layr.layerCount = layr.layers.length;
+  layr.rowCount = layr.rows.length;
+  layr.keyCount = layr.keys.length;
+
+  let offset = constants.length_layr +
+    (constants.length_layr_list * layr.listCount) +
+    (constants.length_layr_entry * layr.layerCount) +
+    (constants.length_layr_row * layr.rowCount) +
+    (constants.length_layr_key * layr.keyCount);
+  layr.size = offset;
+  return layr;
+}

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

@@ -0,0 +1,95 @@
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { List, ListItem } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+ * list section
+   ------------------------------------------------------------------ */
+
+/**
+ * A list entry.
+ */
+interface BUILDER_LIST_LIST {
+  index: number; // index into indices[] subtable
+  count: number; // number of strings in this list
+  _value: ListItem; // for locating the list during finalization
+};
+
+interface BUILDER_LIST_INDEX {
+  str: number; // str for this string
+  _value: string; // for locating this string during finalization
+};
+
+/**
+ * Builder for the 'list' section
+ */
+export interface BUILDER_LIST extends BUILDER_SECTION {
+  listCount: number; // Number of lists total in the subtable
+  indexCount: number; // Total number of indices in the subtable
+  lists: BUILDER_LIST_LIST[];
+  indices: BUILDER_LIST_INDEX[];
+};
+
+export function build_list(source_list: List, sect_strs: BUILDER_STRS): BUILDER_LIST {
+  if(!source_list?.lists?.length) {
+    // there's always the null list
+    return null;
+  }
+
+  let result: BUILDER_LIST = {
+    ident: constants.hex_section_id(constants.section.list),
+    size: 0,
+    _offset: 0,
+    listCount: source_list.lists.length,
+    indexCount: 0,
+    lists: [],
+    indices: [],
+  };
+
+  result.lists = source_list.lists.map(array => {
+    let list : BUILDER_LIST_LIST = {
+      index: result.indices.length, // the next indexcount
+      count: array.length,
+      _value: array
+    };
+    array.forEach((i) => {
+      let index : BUILDER_LIST_INDEX = {
+        // Get the final string index
+        str: build_strs_index(sect_strs, i.value),
+        _value: i.value.value, // unwrap the actual string value
+      };
+      result.indices.push(index); // increment the indexCount
+      result.indexCount++;
+    });
+    return list;
+  });
+
+  // Sort the lists.
+  result.lists.sort((a,b) => a._value.compareTo(b._value));
+
+  let offset = constants.length_list +
+    (constants.length_list_item * result.listCount) +
+    (constants.length_list_index * result.indexCount);
+  result.size = offset;
+
+  return result;
+}
+
+/**
+ * Returns the index into the list, analagous to build_strs_index
+ * @param sect_strs
+ * @param value
+ * @returns
+ */
+export function build_list_index(sect_list: BUILDER_LIST, value: ListItem) {
+  if(!(value instanceof ListItem)) {
+    throw new Error('unexpected value '+ value);
+  }
+
+  let result = sect_list.lists.findIndex(v => v._value === value);
+  if(result < 0) {
+    throw new Error('unexpectedly missing ListItem ' + value); // TODO-LDML: it's an array of strs
+  }
+  return result;
+}

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

@@ -0,0 +1,34 @@
+
+/* ------------------------------------------------------------------
+ * loca section
+   ------------------------------------------------------------------ */
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlusData } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/**
+ * Builder for the 'loca' section
+ */
+export interface BUILDER_LOCA extends BUILDER_SECTION {
+  count: number;
+  items: number[]; //str[]
+};
+
+export function build_loca(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS): BUILDER_LOCA {
+  let loca: BUILDER_LOCA = {
+    ident: constants.hex_section_id(constants.section.loca),
+    size: constants.length_loca + constants.length_loca_item * kmxplus.loca.locales.length,
+    _offset: 0,
+    count: kmxplus.loca.locales.length,
+    items: []
+  };
+
+  for(let item of kmxplus.loca.locales) {
+    loca.items.push(build_strs_index(sect_strs, item));
+  }
+
+  return loca;
+}
+

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

@@ -0,0 +1,37 @@
+
+/* ------------------------------------------------------------------
+ * meta section
+   ------------------------------------------------------------------ */
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlusData } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/**
+ * Builder for the 'meta' section
+ */
+export interface BUILDER_META extends BUILDER_SECTION {
+  author: number; //str
+  conform: number; //str
+  layout: number; //str
+  normalization: number; //str
+  indicator: number; //str
+  version: number; //str
+  settings: number; //bitfield
+};
+
+export function build_meta(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS): BUILDER_META {
+  return {
+    ident: constants.hex_section_id(constants.section.meta),
+    size: constants.length_meta,
+    _offset: 0,
+    author: build_strs_index(sect_strs, kmxplus.meta.author),
+    conform: build_strs_index(sect_strs, kmxplus.meta.conform),
+    layout: build_strs_index(sect_strs, kmxplus.meta.layout),
+    normalization: build_strs_index(sect_strs, kmxplus.meta.normalization),
+    indicator: build_strs_index(sect_strs, kmxplus.meta.indicator),
+    version: build_strs_index(sect_strs, kmxplus.meta.version),
+    settings: kmxplus.meta.settings ?? 0,
+  };
+}

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

@@ -0,0 +1,37 @@
+
+/* ------------------------------------------------------------------
+ * name section
+   ------------------------------------------------------------------ */
+
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlusData } from "../kmx-plus.js";
+import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/**
+ * Builder for the 'name' section
+ */
+export interface BUILDER_NAME extends BUILDER_SECTION {
+  count: number;
+  items: number[]; //str[]
+};
+
+export function build_name(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS): BUILDER_NAME {
+  if(!kmxplus.name.names.length) {
+    return null;
+  }
+
+  let name: BUILDER_NAME = {
+    ident: constants.hex_section_id(constants.section.name),
+    size: constants.length_name + constants.length_name_item * kmxplus.name.names.length,
+    _offset: 0,
+    count: kmxplus.name.names.length,
+    items: []
+  };
+
+  for(let item of kmxplus.name.names) {
+    name.items.push(build_strs_index(sect_strs, item));
+  }
+
+  return name;
+}

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

@@ -0,0 +1,45 @@
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlusData } from "../kmx-plus.js";
+import { build_elem_index, BUILDER_ELEM } from "./build-elem.js";
+import { BUILDER_STRS } from "./build-strs.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+* ordr section
+  ------------------------------------------------------------------ */
+
+interface BUILDER_ORDR_ITEM {
+  elements: number; //elem.string
+  before: number; //elem.string
+};
+
+export interface BUILDER_ORDR extends BUILDER_SECTION {
+ count: number;
+ items: BUILDER_ORDR_ITEM[];
+};
+
+/**
+* Builder for the 'ordr' section
+*/
+export function build_ordr(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS, sect_elem: BUILDER_ELEM): BUILDER_ORDR {
+ if(!kmxplus.ordr?.items.length) {
+   return null;
+ }
+
+ let ordr: BUILDER_ORDR = {
+   ident: constants.hex_section_id(constants.section.ordr),
+   size: constants.length_ordr + constants.length_ordr_item * kmxplus.ordr.items.length,
+   _offset: 0,
+   count: kmxplus.ordr.items.length,
+   items: []
+ };
+
+ for(let item of kmxplus.ordr.items) {
+   ordr.items.push({
+    elements: build_elem_index(sect_elem, item.elements),
+    before: build_elem_index(sect_elem, item.before)
+   });
+ }
+
+ return ordr;
+}

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

@@ -0,0 +1,31 @@
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+ * sect section
+   ------------------------------------------------------------------ */
+
+interface BUILDER_SECT_ITEM {
+  sect: number;
+  offset: number; //? new r.VoidPointer(r.uint32le, {type: 'global'})
+};
+
+/**
+ * Builder for the 'sect' (Section table of contents) section
+ */
+export interface BUILDER_SECT extends BUILDER_SECTION {
+    total: number;
+    count: number;
+    items: BUILDER_SECT_ITEM[];
+  };
+
+export function build_sect(): BUILDER_SECT {
+  return {
+    ident: constants.hex_section_id(constants.section.sect),
+    size: 0, // finalized later
+    _offset: 0,
+    total: 0, // finalized later
+    count: 0, // finalized later
+    items: [], // finalized later
+  };
+}

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

@@ -0,0 +1,58 @@
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { Strs, StrsItem } from "../kmx-plus.js";
+import { BUILDER_SECTION } from "./builder-section.js";
+
+/* ------------------------------------------------------------------
+ * strs section
+   ------------------------------------------------------------------ */
+
+interface BUILDER_STRS_ITEM {
+  // While we use length which is number of utf-16 code units excluding null terminator,
+  // we always write a null terminator, so we can get restructure to do that for us here
+  offset: number; //? new r.Pointer(r.uint32le, new r.String(null, 'utf16le')),
+  length: number; // in UTF-16 code units
+  _value: string
+};
+
+/**
+ * Builder for the 'strs' section
+ */
+export interface BUILDER_STRS extends BUILDER_SECTION {
+  count: number;
+  items: BUILDER_STRS_ITEM[];
+};
+
+export function build_strs(source_strs: Strs): BUILDER_STRS {
+  let result: BUILDER_STRS = {
+    ident: constants.hex_section_id(constants.section.strs),
+    size: 0,  // finalized later
+    _offset: 0,
+    count: source_strs.strings.length,
+    items: [], // filled below
+  };
+
+  result.items = source_strs.strings.map(item => { return {_value: item.value, length: item.value.length, offset: 0}; });
+  result.items.sort((a,b) => StrsItem.binaryStringCompare(a._value, b._value));
+
+  let offset = constants.length_strs + constants.length_strs_item * result.count;
+  // TODO: consider padding
+  for(let item of result.items) {
+    item.offset = offset;
+    offset += item.length * 2 + 2; /* UTF-16 code units + sizeof null terminator */
+  }
+  result.size = offset;
+
+  return result;
+}
+
+export function build_strs_index(sect_strs: BUILDER_STRS, value: StrsItem) {
+  if(!(value instanceof StrsItem)) {
+    throw new Error('unexpected value '+ value);
+  }
+
+  let result = sect_strs.items.findIndex(v => v._value === value.value);
+  if(result < 0) {
+    throw new Error('unexpectedly missing StrsItem '+value.value);
+  }
+  return result;
+}