@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/definition/property/Access.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Access = void 0;
+class Access {
+    constructor() {
+        this.isReadable = false;
+        this.isWritable = false;
+        this.isNotifiable = false;
+    }
+    static of(readable, writable, notifiable) {
+        const thiz = new Access();
+        thiz.isReadable = readable;
+        thiz.isWritable = writable;
+        thiz.isNotifiable = notifiable;
+        return thiz;
+    }
+    static create(access) {
+        const thiz = new Access();
+        for (const v of access) {
+            switch (v) {
+                case 'read':
+                    thiz.isReadable = true;
+                    break;
+                case 'write':
+                    thiz.isWritable = true;
+                    break;
+                case 'notify':
+                    thiz.isNotifiable = true;
+                    break;
+            }
+        }
+        return thiz;
+    }
+    toList() {
+        const array = [];
+        if (this.isReadable) {
+            array.push('read');
+        }
+        if (this.isWritable) {
+            array.push('write');
+        }
+        if (this.isNotifiable) {
+            array.push('notify');
+        }
+        return array;
+    }
+    toString() {
+        const array = [];
+        if (this.isReadable) {
+            array.push('R');
+        }
+        if (this.isWritable) {
+            array.push('W');
+        }
+        if (this.isNotifiable) {
+            array.push('N');
+        }
+        return array.join(' ');
+    }
+    toZhCNList() {
+        const array = [];
+        if (this.isReadable) {
+            array.push('可读');
+        }
+        if (this.isWritable) {
+            array.push('可写');
+        }
+        if (this.isNotifiable) {
+            array.push('可通知');
+        }
+        return array;
+    }
+    toListOptions() {
+        const array = [];
+        if (this.isReadable) {
+            array.push({ key: 'read', value: '可读' });
+        }
+        if (this.isWritable) {
+            array.push({ key: 'write', value: '可写' });
+        }
+        if (this.isNotifiable) {
+            array.push({ key: 'notify', value: '可通知' });
+        }
+        return array;
+    }
+}
+exports.Access = Access;

package/dist/xiot/core/spec/typedef/definition/property/ConstraintValue.d.ts

@@ -0,0 +1,4 @@
+import { DataValue } from './data/DataValue';
+export interface ConstraintValue {
+    validate(value: DataValue<any>): boolean;
+}

package/dist/xiot/core/spec/typedef/definition/property/ConstraintValue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/xiot/core/spec/typedef/definition/property/ValueDefinition.d.ts

@@ -0,0 +1,7 @@
+import { DataValue } from './data/DataValue';
+import { DataFormat } from './data/DataFormat';
+export declare class ValueDefinition {
+    value: DataValue<any>;
+    description: Map<string, string>;
+    constructor(format: DataFormat, value: Object, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/property/ValueDefinition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueDefinition = void 0;
+const DataValueFactory_1 = require("./data/DataValueFactory");
+class ValueDefinition {
+    constructor(format, value, description) {
+        this.description = new Map();
+        this.description = description;
+        this.value = DataValueFactory_1.DataValueFactory.create(format, value);
+    }
+}
+exports.ValueDefinition = ValueDefinition;

package/dist/xiot/core/spec/typedef/definition/property/ValueList.d.ts

@@ -0,0 +1,8 @@
+import { ConstraintValue } from './ConstraintValue';
+import { ValueDefinition } from './ValueDefinition';
+import { DataValue } from './data/DataValue';
+export declare class ValueList implements ConstraintValue {
+    values: ValueDefinition[];
+    validate(value: DataValue<any>): boolean;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/definition/property/ValueList.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueList = void 0;
+class ValueList {
+    constructor() {
+        this.values = [];
+    }
+    validate(value) {
+        for (const v of this.values) {
+            if (v.value.equals(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    toString() {
+        const v = this.values.map(x => x.value.rawValue());
+        return v.join(",");
+    }
+}
+exports.ValueList = ValueList;

package/dist/xiot/core/spec/typedef/definition/property/ValueRange.d.ts

@@ -0,0 +1,18 @@
+import { ConstraintValue } from './ConstraintValue';
+import { DataFormat } from './data/DataFormat';
+import { DataValue } from './data/DataValue';
+export declare class ValueRange implements ConstraintValue {
+    format: DataFormat | null;
+    minValue: DataValue<any> | null;
+    maxValue: DataValue<any> | null;
+    stepValue: DataValue<any> | null;
+    hasStep: boolean;
+    constructor(format: DataFormat, list: any[]);
+    private init;
+    min(value: any): void;
+    max(value: any): void;
+    step(value: any): void;
+    validate(value: DataValue<any>): boolean;
+    toList(): any[];
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/definition/property/ValueRange.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueRange = void 0;
+const DataFormat_1 = require("./data/DataFormat");
+const DataValueFactory_1 = require("./data/DataValueFactory");
+class ValueRange {
+    constructor(format, list) {
+        this.format = null;
+        this.minValue = null;
+        this.maxValue = null;
+        this.stepValue = null;
+        this.hasStep = false;
+        if (list.length === 2) {
+            this.init(format, list[0], list[1], null);
+        }
+        else if (list.length === 3) {
+            this.init(format, list[0], list[1], list[2]);
+        }
+        else {
+            throw new Error('invalid range');
+        }
+    }
+    init(format, min, max, step) {
+        this.format = format;
+        this.minValue = DataValueFactory_1.DataValueFactory.create(format, min);
+        this.maxValue = DataValueFactory_1.DataValueFactory.create(format, max);
+        if (this.minValue == null) {
+            throw new Error(`minValue invalid: ${min}`);
+        }
+        if (this.maxValue == null) {
+            throw new Error(`maxValue invalid: ${max}`);
+        }
+        if (step != null) {
+            this.stepValue = DataValueFactory_1.DataValueFactory.create(format, step);
+            this.hasStep = true;
+            if (this.stepValue == null) {
+                throw new Error(`stepValue invalid: ${step}`);
+            }
+        }
+        else {
+            this.stepValue = null;
+            this.hasStep = false;
+        }
+        if (!this.minValue.lessEquals(this.maxValue)) {
+            throw new Error(`invalid value range: ${min} <= ${max} format: ${(0, DataFormat_1.DataFormatToString)(format)}`);
+        }
+    }
+    min(value) {
+        if (this.format == null) {
+            return;
+        }
+        this.minValue = DataValueFactory_1.DataValueFactory.create(this.format, value);
+    }
+    max(value) {
+        if (this.format == null) {
+            return;
+        }
+        this.maxValue = DataValueFactory_1.DataValueFactory.create(this.format, value);
+    }
+    step(value) {
+        if (this.format == null) {
+            return;
+        }
+        this.stepValue = DataValueFactory_1.DataValueFactory.create(this.format, value);
+    }
+    validate(value) {
+        if (this.minValue == null) {
+            console.log('validate failed, minValue is null');
+            return false;
+        }
+        if (this.maxValue == null) {
+            console.log('validate failed, maxValue is null');
+            return false;
+        }
+        if (this.stepValue == null) {
+            return value.validate(this.minValue, this.maxValue);
+        }
+        return value.validate(this.minValue, this.maxValue, this.stepValue);
+    }
+    toList() {
+        if (this.minValue == null || this.maxValue == null) {
+            return [];
+        }
+        if (this.stepValue != null) {
+            return [this.minValue.rawValue(), this.maxValue.rawValue(), this.stepValue.rawValue()];
+        }
+        return [this.minValue.rawValue(), this.maxValue.rawValue()];
+    }
+    toString() {
+        const array = [];
+        if (this.minValue != null) {
+            array.push(this.minValue.rawValue());
+        }
+        if (this.maxValue != null) {
+            array.push(this.maxValue.rawValue());
+        }
+        if (this.stepValue != null) {
+            array.push(this.stepValue.rawValue());
+        }
+        return JSON.stringify(array);
+    }
+}
+exports.ValueRange = ValueRange;

package/dist/xiot/core/spec/typedef/definition/property/data/DataFormat.d.ts

@@ -0,0 +1,23 @@
+import { DataValue } from "./DataValue";
+export declare enum DataFormat {
+    UNKNOWN = "unknown",
+    BOOL = "bool",
+    UINT8 = "uint8",
+    UINT16 = "uint16",
+    UINT32 = "uint32",
+    INT8 = "int8",
+    INT16 = "int16",
+    INT32 = "int32",
+    INT64 = "int64",
+    FLOAT = "float",
+    STRING = "string",
+    HEX = "hex",
+    TLV8 = "tlv8",
+    COMBINATION = "combination"
+}
+export declare function DataFormatCheck(format: DataFormat, value: DataValue<any>): boolean;
+export declare function DataFormatToString(format: DataFormat): string;
+export declare function DataFormatFromString(format: string): DataFormat;
+export declare function getFormatJSBase(format: string): "unknown" | "string" | "boolean" | "number" | "object";
+export declare function getValueRangeEnabled(format: DataFormat): boolean;
+export declare function getValueListEnabled(format: DataFormat): boolean;

package/dist/xiot/core/spec/typedef/definition/property/data/DataFormat.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFormat = void 0;
+exports.DataFormatCheck = DataFormatCheck;
+exports.DataFormatToString = DataFormatToString;
+exports.DataFormatFromString = DataFormatFromString;
+exports.getFormatJSBase = getFormatJSBase;
+exports.getValueRangeEnabled = getValueRangeEnabled;
+exports.getValueListEnabled = getValueListEnabled;
+var DataFormat;
+(function (DataFormat) {
+    DataFormat["UNKNOWN"] = "unknown";
+    DataFormat["BOOL"] = "bool";
+    DataFormat["UINT8"] = "uint8";
+    DataFormat["UINT16"] = "uint16";
+    DataFormat["UINT32"] = "uint32";
+    DataFormat["INT8"] = "int8";
+    DataFormat["INT16"] = "int16";
+    DataFormat["INT32"] = "int32";
+    DataFormat["INT64"] = "int64";
+    DataFormat["FLOAT"] = "float";
+    DataFormat["STRING"] = "string";
+    DataFormat["HEX"] = "hex";
+    DataFormat["TLV8"] = "tlv8";
+    DataFormat["COMBINATION"] = "combination";
+})(DataFormat || (exports.DataFormat = DataFormat = {}));
+function DataFormatCheck(format, value) {
+    return format == value.getFormat();
+}
+function DataFormatToString(format) {
+    return format.toString();
+}
+function DataFormatFromString(format) {
+    const keys = Object.keys(DataFormat);
+    for (const key of keys) {
+        const s = DataFormatToString(DataFormat[key]);
+        if (s === format) {
+            return DataFormat[key];
+        }
+    }
+    return DataFormat.UNKNOWN;
+}
+function getFormatJSBase(format) {
+    switch (format) {
+        case 'bool':
+            return 'boolean';
+        case 'uint8':
+        case 'uint16':
+        case 'unit32':
+        case 'int8':
+        case 'int16':
+        case 'int32':
+        case 'int64':
+        case 'float':
+            return 'number';
+        case 'string':
+        case 'hex':
+        case 'tlv8':
+            return 'string';
+        case 'object':
+            return 'object';
+        default:
+            return 'unknown';
+    }
+}
+function getValueRangeEnabled(format) {
+    switch (format) {
+        case DataFormat.UINT8:
+        case DataFormat.UINT16:
+        case DataFormat.UINT32:
+        case DataFormat.INT8:
+        case DataFormat.INT16:
+        case DataFormat.INT32:
+        case DataFormat.INT64:
+        case DataFormat.FLOAT:
+        case DataFormat.HEX:
+            return true;
+        default:
+            return false;
+    }
+}
+function getValueListEnabled(format) {
+    switch (format) {
+        case DataFormat.UINT8:
+        case DataFormat.UINT16:
+        case DataFormat.UINT32:
+        case DataFormat.INT8:
+        case DataFormat.INT16:
+        case DataFormat.INT32:
+        case DataFormat.INT64:
+        case DataFormat.HEX:
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/xiot/core/spec/typedef/definition/property/data/DataValue.d.ts

@@ -0,0 +1,8 @@
+import { DataFormat } from './DataFormat';
+export interface DataValue<T> {
+    equals(other: DataValue<T>): boolean;
+    lessEquals(maxValue: DataValue<T>): boolean;
+    validate(min: DataValue<T>, max: DataValue<T>, step?: DataValue<T>): boolean;
+    rawValue(): T;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/DataValue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/xiot/core/spec/typedef/definition/property/data/DataValueFactory.d.ts

@@ -0,0 +1,7 @@
+import { DataValue } from './DataValue';
+import { DataFormat } from './DataFormat';
+export declare class DataValueFactory {
+    static createDefaultValue(format: DataFormat): DataValue<any>;
+    static create(format: DataFormat, value: Object): DataValue<any>;
+    static createFromString(format: DataFormat, value: string): DataValue<any>;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/DataValueFactory.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataValueFactory = void 0;
+const DataFormat_1 = require("./DataFormat");
+const Vbool_1 = require("./value/Vbool");
+const Vstring_1 = require("./value/Vstring");
+const Vfloat_1 = require("./value/Vfloat");
+const Vuint8_1 = require("./value/Vuint8");
+const Vuint16_1 = require("./value/Vuint16");
+const Vuint32_1 = require("./value/Vuint32");
+const Vint8_1 = require("./value/Vint8");
+const Vint16_1 = require("./value/Vint16");
+const Vint32_1 = require("./value/Vint32");
+const Vint64_1 = require("./value/Vint64");
+const Vhex_1 = require("./value/Vhex");
+const Vtlv8_1 = require("./value/Vtlv8");
+const Vcombination_1 = require("./value/Vcombination");
+class DataValueFactory {
+    static createDefaultValue(format) {
+        switch (format) {
+            case DataFormat_1.DataFormat.BOOL:
+                return new Vbool_1.Vbool();
+            case DataFormat_1.DataFormat.STRING:
+                return new Vstring_1.Vstring();
+            case DataFormat_1.DataFormat.FLOAT:
+                return new Vfloat_1.Vfloat();
+            case DataFormat_1.DataFormat.UINT8:
+                return new Vuint8_1.Vuint8();
+            case DataFormat_1.DataFormat.UINT16:
+                return new Vuint16_1.Vuint16();
+            case DataFormat_1.DataFormat.UINT32:
+                return new Vuint32_1.Vuint32();
+            case DataFormat_1.DataFormat.INT8:
+                return new Vint8_1.Vint8();
+            case DataFormat_1.DataFormat.INT16:
+                return new Vint16_1.Vint16();
+            case DataFormat_1.DataFormat.INT32:
+                return new Vint32_1.Vint32();
+            case DataFormat_1.DataFormat.INT64:
+                return new Vint64_1.Vint64();
+            case DataFormat_1.DataFormat.HEX:
+                return new Vhex_1.Vhex();
+            case DataFormat_1.DataFormat.TLV8:
+                return new Vtlv8_1.Vtlv8();
+            case DataFormat_1.DataFormat.COMBINATION:
+                return new Vcombination_1.Vcombination();
+            default:
+                throw new Error(`format invalid: ${format}`);
+        }
+    }
+    static create(format, value) {
+        switch (format) {
+            case DataFormat_1.DataFormat.BOOL:
+                return Vbool_1.Vbool.create(value);
+            case DataFormat_1.DataFormat.STRING:
+                return Vstring_1.Vstring.create(value);
+            case DataFormat_1.DataFormat.FLOAT:
+                return Vfloat_1.Vfloat.create(value);
+            case DataFormat_1.DataFormat.UINT8:
+                return Vuint8_1.Vuint8.create(value);
+            case DataFormat_1.DataFormat.UINT16:
+                return Vuint16_1.Vuint16.create(value);
+            case DataFormat_1.DataFormat.UINT32:
+                return Vuint32_1.Vuint32.create(value);
+            case DataFormat_1.DataFormat.INT8:
+                return Vint8_1.Vint8.create(value);
+            case DataFormat_1.DataFormat.INT16:
+                return Vint16_1.Vint16.create(value);
+            case DataFormat_1.DataFormat.INT32:
+                return Vint32_1.Vint32.create(value);
+            case DataFormat_1.DataFormat.INT64:
+                return Vint64_1.Vint64.create(value);
+            case DataFormat_1.DataFormat.HEX:
+                return Vhex_1.Vhex.create(value);
+            case DataFormat_1.DataFormat.TLV8:
+                return Vtlv8_1.Vtlv8.create(value);
+            case DataFormat_1.DataFormat.COMBINATION:
+                return Vcombination_1.Vcombination.create(value);
+            default:
+                throw new Error(`format invalid: ${format}`);
+        }
+    }
+    static createFromString(format, value) {
+        switch (format) {
+            case DataFormat_1.DataFormat.BOOL:
+                return Vbool_1.Vbool.fromString(value);
+            case DataFormat_1.DataFormat.STRING:
+                return Vstring_1.Vstring.create(value);
+            case DataFormat_1.DataFormat.FLOAT:
+                return Vfloat_1.Vfloat.fromString(value);
+            case DataFormat_1.DataFormat.UINT8:
+                return Vuint8_1.Vuint8.fromString(value);
+            case DataFormat_1.DataFormat.UINT16:
+                return Vuint16_1.Vuint16.fromString(value);
+            case DataFormat_1.DataFormat.UINT32:
+                return Vuint32_1.Vuint32.fromString(value);
+            case DataFormat_1.DataFormat.INT8:
+                return Vint8_1.Vint8.fromString(value);
+            case DataFormat_1.DataFormat.INT16:
+                return Vint16_1.Vint16.fromString(value);
+            case DataFormat_1.DataFormat.INT32:
+                return Vint32_1.Vint32.fromString(value);
+            case DataFormat_1.DataFormat.INT64:
+                return Vint64_1.Vint64.fromString(value);
+            case DataFormat_1.DataFormat.HEX:
+                return Vhex_1.Vhex.fromString(value);
+            case DataFormat_1.DataFormat.TLV8:
+                return Vtlv8_1.Vtlv8.fromString(value);
+            case DataFormat_1.DataFormat.COMBINATION:
+            default:
+                throw new Error(`format invalid: ${format}`);
+        }
+    }
+}
+exports.DataValueFactory = DataValueFactory;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vbool.d.ts

@@ -0,0 +1,12 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vbool implements DataValue<boolean> {
+    private value;
+    static create(value: Object): Vbool;
+    static fromString(value: string): Vbool;
+    equals(other: DataValue<boolean>): boolean;
+    lessEquals(maxValue: DataValue<boolean>): boolean;
+    validate(min: DataValue<boolean>, max: DataValue<boolean>, step?: DataValue<boolean>): boolean;
+    rawValue(): boolean;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vbool.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vbool = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vbool {
+    constructor() {
+        this.value = false;
+    }
+    static create(value) {
+        const type = typeof value;
+        switch (type) {
+            case 'boolean':
+                const v = new Vbool();
+                v.value = value;
+                return v;
+            case 'number':
+                const vv = new Vbool();
+                vv.value = value === 1;
+                return vv;
+            default:
+                throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+        }
+    }
+    static fromString(value) {
+        if (value === 'true') {
+            const v = new Vbool();
+            v.value = true;
+            return v;
+        }
+        if (value === 'false') {
+            const v = new Vbool();
+            v.value = false;
+            return v;
+        }
+        throw new Error(`Vbool invalid value: ${value}`);
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(maxValue) {
+        return false;
+    }
+    validate(min, max, step) {
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.BOOL;
+    }
+}
+exports.Vbool = Vbool;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vcombination.d.ts

@@ -0,0 +1,11 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vcombination implements DataValue<any[]> {
+    private value;
+    static create(value: Object): Vcombination;
+    equals(other: DataValue<any[]>): boolean;
+    lessEquals(max: DataValue<any[]>): boolean;
+    validate(min: DataValue<any[]>, max: DataValue<any[]>, step?: DataValue<any[]>): boolean;
+    rawValue(): any[];
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vcombination.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vcombination = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vcombination {
+    constructor() {
+        this.value = [];
+    }
+    static create(value) {
+        if (value instanceof Array) {
+            const v = new Vcombination();
+            v.value.push(...value);
+            return v;
+        }
+        throw new Error(`invalid value: ${value} is not Array`);
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        return false;
+    }
+    validate(min, max, step) {
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.COMBINATION;
+    }
+}
+exports.Vcombination = Vcombination;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vfloat.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vfloat implements DataValue<number> {
+    private value;
+    static create(value: Object): Vfloat;
+    static fromString(value: string): Vfloat;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}