isy-nodejs 0.5.0-beta.8 → 1.0.1-alpha.0

package/src/Model/DriverState.ts

@@ -0,0 +1,13 @@
+import type { UnitOfMeasure } from '../Definitions/Global/UOM.js';
+
+
+
+export interface DriverState {
+	id: string | number;
+	value: any;
+	formatted: string;
+	uom: UnitOfMeasure;
+
+	prec: number;
+	name: string;
+}

package/src/Model/EditorDef.ts

@@ -0,0 +1,46 @@
+import { Family } from '../Definitions/Global/Families.js';
+import type { UnitOfMeasure } from '../Definitions/Global/UOM.js';
+import type { MaybeArray } from '../Utils.js';
+
+export type RangeDef = {
+	uom: UnitOfMeasure;
+	subset: string;
+	nls: string;
+	prec?: number;
+} | {
+  	nls?: string;
+	uom: UnitOfMeasure;
+	min: number;
+	max: number;
+	step: number;
+	prec: number;
+}
+
+
+export interface EditorDef {
+	id: string;
+	range: MaybeArray<RangeDef>
+}
+
+
+export const EditorDefMap : Map<Family, {[x: string]: EditorDef}> = new Map();
+
+export function buildEditorDefMap<T extends Family>(editorDefs: EditorDef[], family: T) {
+    const map: {[x: string]: EditorDef} = {};
+    for(const editorDef of editorDefs) {
+        map[editorDef.id] = editorDef;
+    }
+
+    EditorDefMap.set(family, map);
+    return map;
+}
+
+export namespace EditorDef {
+	export function get<T extends Family>(family: T, id: string): EditorDef | undefined {
+		if(EditorDefMap.has(family)) {
+			return EditorDefMap.get(family)[id];
+		}
+	}
+
+	export const Map = EditorDefMap;
+}

package/src/Model/EnumDefinition.ts

@@ -0,0 +1,127 @@
+import camelcase from 'camelcase';
+import { Family } from '../Definitions/Global/Families.js';
+import { applyTranslations, NLSIndexMap } from './NLS.js';
+import { camelCase, merge, pascalCase } from 'moderndash';
+
+import { UnitOfMeasure } from '../Definitions/Global/UOM.js';
+import fs from 'fs';
+import { factory } from 'typescript';
+
+export class EnumDefinition<T extends Family> {
+	public readonly family: T;
+	public readonly id: string;
+	public name: string;
+	public values: { [y: string]: number } = {};
+	public usages = new Set<`${string}:${keyof typeof UnitOfMeasure}`>();
+	public repType : { type: 'enum' } | {type: 'boolean', trueValue: number, falseValue: number, nullValue?: boolean} | {type: 'const', value: 'number'|'bigint'};
+	constructor(family: T, indexDef: { id: string; values: { [y: number]: string } }) {
+		this.family = family;
+		this.id = indexDef.id;
+		this.name = pascalCase(
+			applyTranslations(family, indexDef.id.replace('IX_I_', '').replace('IX_', '').replace('IXA_', 'Alert')).replace(
+				'IXAV_',
+				'AlertValue'
+			)
+		);
+
+		for (const [index, value] of Object.entries(indexDef.values)) {
+			const label = sanitize(value);
+			this.values[label] = parseInt(index);
+		}
+	}
+}
+
+export namespace EnumDefinition {
+	export function get<T extends Family>(
+		family: T,
+		id: string,
+		uom: UnitOfMeasure,
+		nodeDefId: string
+	): EnumDefinition<T> | undefined {
+		if (EnumDefinitionMap.has(family)) {
+			var enumDef = EnumDefinitionMap.get(family)[id];
+			if (enumDef) {
+				enumDef.usages.add(`${nodeDefId}:${UnitOfMeasure[uom] as keyof typeof UnitOfMeasure}`);
+				return enumDef as EnumDefinition<T>;
+			}
+		}
+	}
+
+	export function generate<T extends Family = Family>(family?: T) {
+		if (!family) {
+			//return generateAll();
+		}
+		let enumDefs = EnumDefinitionMap;
+		let indexDefs = NLSIndexMap.get(family);
+		let familyEnumDefs: { [x: string]: EnumDefinition<Family> };
+		for (const id in indexDefs) {
+			familyEnumDefs[id] = new EnumDefinition(family, { id, values: indexDefs[id] });
+		}
+		enumDefs.set(family, familyEnumDefs);
+		return enumDefs.get(family);
+	}
+
+	export function* generateAll(): any {
+		for (const family of NLSIndexMap.keys()) {
+			yield generate(family);
+		}
+	}
+
+	export function load(path: string) {
+		if (!fs.existsSync(path + '/generated')) {
+			fs.mkdirSync(path + '/generated', { recursive: true });
+		}
+		if (!fs.existsSync(path + '/overrides')) {
+			fs.mkdirSync(path + '/overrides');
+		}
+		for (const file of new Set(fs.readdirSync(path + '/generated').concat(fs.readdirSync(path + '/overrides')))) {
+			const fam = file.replace('.json', '');
+			const family = Family[fam];
+			let enumDefs = {};
+			if (fs.existsSync(`${path}/generated/${fam}.json`)) {
+				enumDefs = JSON.parse(fs.readFileSync(`${path}/generated/${fam}.json`, 'utf8')) as {
+					[x: string]: EnumDefinition<Family>;
+				};
+			}
+
+			if (fs.existsSync(`${path}/overrides/${fam}.json`)) {
+				enumDefs = merge(
+					enumDefs,
+					JSON.parse(fs.readFileSync(`${path}/overrides/${fam}.json`, 'utf8')) as {
+						[x: string]: EnumDefinition<Family>;
+					}
+				);
+			}
+			for (const id in enumDefs) {
+				enumDefs[id].usages = new Set();
+			}
+			EnumDefinitionMap.set(family, enumDefs);
+		}
+		return EnumDefinitionMap;
+	}
+}
+
+export const EnumDefinitionMap: Map<Family, { [x: string]: EnumDefinition<Family> }> = new Map();
+
+export function buildEnumDefinitions(NLSIndexMap: Map<Family, { [x: string]: { [y: number]: string } }>) {
+	let enumDefs = EnumDefinitionMap;
+	for (const [family, indexDefs] of NLSIndexMap) {
+		let familyEnumDefs: { [x: string]: EnumDefinition<Family> } = {};
+		for (const id in indexDefs) {
+			familyEnumDefs[id] = new EnumDefinition(family, { id, values: indexDefs[id] });
+		}
+		enumDefs.set(family, familyEnumDefs);
+	}
+	return enumDefs;
+}
+function createMemberName(name: string, mapNullishTo: string = 'Unknown'): any {
+	let label = pascalCase(name) ?? 'Unknown';
+	if (!label.substring(0, 1).match(/[a-zA-Z]/)) {
+		return factory.createStringLiteral(label);
+	}
+	return factory.createIdentifier(label);
+}
+
+function sanitize(value: string) {
+  return pascalCase(value).replace(/[^a-zA-Z0-9]/g, '');
+}

package/src/Model/Message.ts

@@ -0,0 +1,9 @@
+export interface Message<TEventInfo> {
+    seqnum: number;
+    sid: string;
+    timestamp: string;
+    control: string;
+    action: string;
+    node: string;
+    eventInfo: TEventInfo;
+}

package/src/Model/NLS.ts

@@ -0,0 +1,449 @@
+import { merge } from 'moderndash';
+import type { DriverType } from "../Definitions/Global/Drivers.js";
+import { Family } from "../Definitions/Global/Families.js";
+import "../Utils.js";
+import type { TransactionalInteractionServer } from '@project-chip/matter.js/node/server';
+
+export enum NLSRecordType {
+  Generic = "GEN",
+  Driver = "ST",
+  Command = "CMD",
+  NodeDef = "ND",
+  NodeDefNLS = "NDN",
+  DeviceInfo = "DEV",
+  CommandParameter = "CMDP",
+  CommandParameterNLS = "CMDPN",
+  LinkProtocol = "LNKP",
+  LinkParameter = "LNKD",
+  Index = "IX",
+  Other = "OTHER",
+  Program = "PGM",
+}
+
+export type NLSRecordTypeMap = {
+    "GEN"?:  NLSGenericRecord[],
+    "ST"?:  NLSDriverRecord[],
+    "CMD"?:  NLSCommandRecord[],
+    "ND"?:  {type: NLSRecordType.NodeDef, nodeDefId: string, property: string, meta: string, value: string}[],
+    "NDN"?: {type: NLSRecordType.NodeDefNLS, nlsId: string, property: string, meta: string, value: string}[],
+    "DEV"?: {type: NLSRecordType.DeviceInfo, deviceCode: string, property: string, meta: string, value: string}[],
+    "CMDP"?:  NLSCommandParameterRecord[],
+    "CMDPN"?: NLSCommandParameterRecord[],
+    "LNKP"?: {type: NLSRecordType.LinkProtocol, protocol: string, property: string, meta: string, value: string}[],
+    "LNKD"?: {type: NLSRecordType.LinkParameter, parameter: string, property: string, meta: string, value: string}[],
+    "IX"?: {type: NLSRecordType.Index, indexType: string, indexValue: number, value: string}[],
+    "OTHER"?: {type: NLSRecordType.Other, key: string, value: string}[],
+    "PGM"?: {type: NLSRecordType.Program, key: string, value: string}[],
+}
+
+export interface NLSRecord<T extends NLSRecordType> {
+  type: T;
+  value: string;
+  nlsId?: string;
+}
+
+export class NLSBaseRecord<T extends NLSRecordType> implements NLSRecord<T> {
+  type: T;
+  key: string;
+  value: string;
+}
+
+interface NLSRecordMap {
+  [key: string]: NLSRecord<NLSRecordType>;
+}
+
+export abstract class NLSNodeDefFilteredRecord<T extends NLSRecordType> implements NLSRecord<T> {
+  readonly type: T;
+  nlsId?: string;
+  readonly value: string;
+  meta: string;
+  constructor(type: T, tokens: string[], value: string) {
+    this.type = type;
+    this.value = value;
+
+  }
+  parseKey(tokens: string[]) {
+    this.nlsId = tokens.pop() ?? 'Generic';
+    this.meta = tokens.length > 0 ? tokens.join("-") : undefined;
+  }
+}
+
+export class NLSCommandRecord extends NLSNodeDefFilteredRecord<NLSRecordType.Command> {
+  control: string;
+  property: string;
+  constructor(tokens: string[], value: string) {
+    super(NLSRecordType.Command, tokens, value);
+    this.parseKey(tokens);
+
+  }
+  override parseKey(tokens: string[]) {
+
+    this.property = tokens.pop();
+    this.control = tokens.pop();
+    super.parseKey(tokens);
+  }
+}
+
+export class NLSGenericRecord extends NLSNodeDefFilteredRecord<NLSRecordType.Generic> {
+  control: string;
+  property: string;
+  constructor(tokens: string[], value: string) {
+    super(NLSRecordType.Generic, tokens, value);
+    this.parseKey(tokens);
+  }
+  override parseKey(tokens: string[]) {
+
+    this.property = tokens.pop() ?? 'NAME';
+    this.control = tokens.pop();
+
+    super.parseKey(tokens);
+    //this.property = tokens[1];
+  }
+}
+
+export class NLSCommandParameterRecord extends NLSNodeDefFilteredRecord<NLSRecordType.CommandParameter | NLSRecordType.CommandParameterNLS> {
+  control: string;
+  property: string;
+  editorId: string;
+  constructor(type: NLSRecordType.CommandParameter | NLSRecordType.CommandParameterNLS, tokens: string[], value: string) {
+    super(type, tokens, value);
+
+    this.parseKey(tokens);
+  }
+
+  override parseKey(tokens: string[]) {
+
+    this.property = tokens.pop();
+    this.control = tokens.pop();
+    if(this.type == NLSRecordType.CommandParameter)
+    {
+      this.editorId = tokens.pop() ?? undefined;
+    }
+
+
+    super.parseKey(tokens);
+  }
+}
+
+export class NLSDriverRecord extends NLSNodeDefFilteredRecord<NLSRecordType.Driver> {
+  control: DriverType;
+  property: string;
+  constructor(tokens: string[], value: string) {
+    super(NLSRecordType.Driver, tokens, value);
+    this.parseKey(tokens);
+  }
+  override parseKey(tokens: string[]) {
+
+    this.property = tokens.pop();
+    this.control = tokens.pop() as DriverType;
+    super.parseKey(tokens);
+  }
+}
+
+export const NLSIndexMap : Map<Family, {[x:string]: {[y: number]:string}}> = new Map();
+export const NLSTranslations : Map<Family, {[y: string]:string}> = new Map();
+
+const StdTranslations = {
+  ONOFF: "OnOff",
+  ZY: "ZWave",
+  ZB: "ZigBee",
+  BOOL: "Boolean",
+  L255: "Level255",
+  PCT: "Percent",
+  DIR: "Direction",
+  SIR: "Siren",
+  MD: "Mode",
+  LVL: "Level",
+  IX: "Index",
+  OPTS: "Options",
+  LST: "List",
+  TMR: "Timer",
+  BRD: "Bridge",
+  CFN: "Configuration",
+  PWR: "Power",
+  VOLT: "Voltage",
+  CURR: "Current",
+  BATLVL: "BatteryLevel",
+  BAT: "Battery",
+  TEMP: "Temperature",
+  HUM: "Humidity",
+  LUM: "Luminance",
+  RR: "RampRate",
+  FL: "FanLevel",
+  BL: "Backlight",
+  ST: "State",
+  STS: "Status",
+  ERR: "Error",
+  PARAM: "Parameter",
+  LEN: "Length",
+  OL: "OnLevel",
+  DLY: "Delay",
+  "+": "With",
+  "(": "",
+  ")": "",
+  TVOL: "ToneVolume",
+  VIB: "Vibration",
+  LGT: "Light",
+  SIRMD: 'SirenMode',
+  SIRTM: 'SirenTime',
+  SIRVL: 'SirenVolume',
+  SIL: 'Silent',
+  ALRT: 'Alert',
+  TF: 'TrueFalse',
+  FTU: 'TrueFalseUnknown',
+
+};
+
+NLSTranslations.set(Family.Generic, StdTranslations);
+
+export function addToIndexMap<T extends Family>(
+family: T, record: {type: NLSRecordType, indexType: string, indexValue: number, value: string, comment: string}){
+    if(!NLSIndexMap.has(family))
+    {
+        NLSIndexMap.set(family, {});
+    }
+    const indexMap = NLSIndexMap.get(family);
+    if(!indexMap[record.indexType])
+    {
+        indexMap[record.indexType] = {};
+    }
+    indexMap[record.indexType][record.indexValue] = record.value;
+}
+
+
+
+export function addToTranslationMap<T extends Family>(family: T, record: NLSGenericRecord | NLSCommandRecord | NLSDriverRecord){
+    if(!NLSTranslations.has(family))
+    {
+        NLSTranslations.set(family, {});
+    }
+    const translationMap = NLSTranslations.get(family);
+
+    if(record.property === 'NAME')
+    {
+        if(record.nlsId == 'Generic')
+        {
+            if(record instanceof NLSGenericRecord)
+              translationMap[record.control] = record.value;
+            else if(record instanceof NLSDriverRecord)
+              translationMap[record.control] = record.value;
+            else if(record instanceof NLSCommandRecord)
+              translationMap[record.control] = record.value;
+        }
+        //translationMap[record.key] = record.value;
+    }
+}
+
+
+
+export function applyTranslations(family: Family, value: string) : string {
+    if(value.includes('_'))
+    {
+        return value.split('_').map((v) => applyTranslations(family, v)).join('_');
+    }
+    value = value.trim();
+    if(family !== Family.Generic)
+    {
+        value = applyTranslations(Family.Generic, value)
+    }
+    if(NLSRecordMap.has(family))
+    {
+        const map = NLSTranslations.get(family);
+        for(const key in map)
+        {
+            if(value == key)
+            {
+              return map[key];
+            }
+        }
+    }
+    return value;
+}
+
+
+export function createMap<T extends Family>(
+  content: string,
+  family: T
+): { [y: string]: NLSRecordTypeMap } {
+  const map: { [y: string]: NLSRecordTypeMap} = {};
+  NLSRecordMap.delete(family);
+  for (const record of parseNLSContent(content, family)) {
+    const key = record.nlsId ?? "Generic";
+
+    if (!map[key]) {
+      map[key] = {};
+    }
+    if (map[key][record.type]) {
+      map[key][record.type].push(record as any);
+    } else {
+      map[key][record.type] = [record as any];
+    }
+  }
+  NLSRecordMap.set(family, map);
+
+  return map;
+}
+
+export const NLSRecordMap: Map<Family, {[y: string]: NLSRecordTypeMap}> = new Map();
+
+export function parseNLSContent<T extends Family>(content: string, family: T): NLSRecord<NLSRecordType>[] {
+  const lines = content.split("\n");
+  const result = [];
+  const NLSRecords = new Array<NLSRecord<NLSRecordType>>();
+  let currentComment = "";
+  lines.forEach((line) => {
+    line = line.trim();
+    if (line === "") {
+
+      return; // Skip comments and empty lines
+    }
+    else if (line.startsWith("#"))
+    {
+        currentComment = line.trim()
+    }
+
+    let [key, value] = line.split("=");
+
+    if (key && value) {
+      key = key.trim();
+      const tokens = key.split("-");
+      value = value.trim();
+      if (tokens.length > 0) {
+        if (tokens[0].startsWith("IX")) {
+          const recordType = NLSRecordType.Index;
+          const indexType = tokens.shift();
+          const indexValue = tokens.shift();
+          const indexNLS = { comment: currentComment, type: recordType, value: value, indexType: indexType, indexValue: Number(indexValue)};
+          NLSRecords.push(indexNLS);
+          addToIndexMap(family, indexNLS)
+        } else {
+          const recordType = tokens.shift() as NLSRecordType;
+          switch (recordType) {
+            case NLSRecordType.Generic:
+              const genericRecord = new NLSGenericRecord(tokens, value);
+              NLSRecords.push(genericRecord);
+              addToTranslationMap(family, genericRecord);
+              break;
+            case NLSRecordType.Driver:
+              const driverRecord = new NLSDriverRecord(tokens, value);
+              NLSRecords.push(driverRecord);
+              addToTranslationMap(family, driverRecord)
+              break;
+            case NLSRecordType.Command:
+              const commandRecord = new NLSCommandRecord(tokens, value);
+              NLSRecords.push(commandRecord);
+              addToTranslationMap(family, commandRecord)
+              break;
+            case NLSRecordType.NodeDef:
+              const nodeDefRecord = {
+                type: recordType,
+                value: value,
+                nodeDefId: tokens.shift(),
+                property: tokens.shift(),
+                meta: tokens.length > 0 ? tokens.join("-") : undefined,
+              };
+              NLSRecords.push(nodeDefRecord);
+              break;
+            case NLSRecordType.NodeDefNLS:
+              const nodeDefNameRecord = {
+                type: recordType,
+                value: value,
+                nlsId: tokens.shift(),
+                property: tokens.shift(),
+                meta: tokens.length > 0 ? tokens.join("-") : undefined,
+              };
+              NLSRecords.push(nodeDefNameRecord);
+              break;
+            case NLSRecordType.DeviceInfo:
+              const deviceInfoRecord = {
+                type: recordType,
+                nlsId: tokens.shift(),
+                property: tokens.shift(),
+                meta: tokens.join("-"),
+                value,
+              };
+              NLSRecords.push(deviceInfoRecord);
+              break;
+            case NLSRecordType.CommandParameter || NLSRecordType.CommandParameterNLS:
+              const commandParameterRecord = new NLSCommandParameterRecord(recordType, tokens, value);
+              NLSRecords.push(commandParameterRecord);
+              break;
+            case NLSRecordType.LinkProtocol:
+              const linkProtocolRecord = {
+                type: recordType,
+                protocol: tokens.shift(),
+                property: tokens.shift(),
+                meta: tokens.length > 0 ? tokens.join("-") : undefined,
+                value,
+              };
+              NLSRecords.push(linkProtocolRecord);
+              break;
+            case NLSRecordType.LinkParameter:
+              const linkParameterRecord = {
+                type: recordType,
+                parameter: tokens.shift(),
+                property: tokens.shift(),
+                meta: tokens.join("-"),
+                value,
+              };
+              NLSRecords.push(linkParameterRecord);
+              break;
+            case NLSRecordType.Program:
+              const programRecord = { type: recordType, key: tokens.join("-"), value };
+              NLSRecords.push(programRecord);
+              break;
+            default:
+              const otherRecord = { type: recordType, key: tokens.join("-"), value };
+              NLSRecords.push(otherRecord);
+              break;
+          }
+        }
+        const key = tokens;
+      }
+      result.push({ tokens, value: value.trim() });
+    }
+  });
+
+  return NLSRecords;
+}
+
+export namespace NLS
+{
+    export function get<T extends Family>(family: T, nlsId: string) {
+        if(NLSRecordMap.has(family)) {
+            return merge(NLSRecordMap.get(Family.Generic)[nlsId], NLSRecordMap.get(family)[nlsId]);
+        }
+    }
+
+    export const Map = NLSRecordMap;
+}
+
+export namespace Translation
+{
+    export const apply = applyTranslations;
+
+    export const Map = NLSTranslations;
+}
+
+export namespace IndexDef
+{
+    export function get<T extends Family>(family: T, indexType: string) : {[y: number]: string}
+    {
+
+        if(NLSIndexMap.has(family))
+        {
+            const indexMap = NLSIndexMap.get(family);
+            if(indexMap[indexType])
+            {
+                return indexMap[indexType];
+            }
+        }
+        if(family != Family.Generic)
+        {
+           return get(Family.Generic, indexType);
+        }
+    }
+
+    export const Map = NLSIndexMap;
+
+}