@openxiot/xiot-core-spec-ts 0.0.2

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

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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vuint32 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vuint32 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vuint32();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vuint32();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vuint32)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vuint32) || !(max instanceof Vuint32)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vuint32) || !(max instanceof Vuint32) || !(step instanceof Vuint32)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.UINT32;
+    }
+}
+exports.Vuint32 = Vuint32;

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

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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vuint8 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vuint8 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vuint8();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vuint8();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vuint8)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vuint8) || !(max instanceof Vuint8)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vuint8) || !(max instanceof Vuint8) || !(step instanceof Vuint8)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.UINT8;
+    }
+}
+exports.Vuint8 = Vuint8;

package/dist/xiot/core/spec/typedef/definition/urn/ActionType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class ActionType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): ActionType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/ActionType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class ActionType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.ACTION], string, exception);
+    }
+    static parse(string) {
+        return new ActionType(string, true);
+    }
+}
+exports.ActionType = ActionType;

package/dist/xiot/core/spec/typedef/definition/urn/DeviceType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class DeviceType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): DeviceType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/DeviceType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class DeviceType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.DEVICE], string, exception);
+    }
+    static parse(string) {
+        return new DeviceType(string, true);
+    }
+}
+exports.DeviceType = DeviceType;

package/dist/xiot/core/spec/typedef/definition/urn/EventType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class EventType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): EventType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/EventType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class EventType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.EVENT], string, exception);
+    }
+    static parse(string) {
+        return new EventType(string, true);
+    }
+}
+exports.EventType = EventType;

package/dist/xiot/core/spec/typedef/definition/urn/Extendable.d.ts

@@ -0,0 +1,11 @@
+export declare class Extendable {
+    _optional: boolean;
+    _property_addable: boolean;
+    _action_addable: boolean;
+    _event_addable: boolean;
+    _just_added: boolean;
+    _changed: boolean;
+    _active: boolean;
+    _checked: boolean;
+    _index: number;
+}

package/dist/xiot/core/spec/typedef/definition/urn/Extendable.js

@@ -0,0 +1,18 @@
+"use strict";
+/* eslint-disable camelcase */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extendable = void 0;
+class Extendable {
+    constructor() {
+        this._optional = false;
+        this._property_addable = false;
+        this._action_addable = false;
+        this._event_addable = false;
+        this._just_added = false;
+        this._changed = false;
+        this._active = false;
+        this._checked = false;
+        this._index = 0;
+    }
+}
+exports.Extendable = Extendable;

package/dist/xiot/core/spec/typedef/definition/urn/FormatType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class FormatType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): FormatType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/FormatType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class FormatType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.FORMAT], string, exception);
+    }
+    static parse(string) {
+        return new FormatType(string, true);
+    }
+}
+exports.FormatType = FormatType;

package/dist/xiot/core/spec/typedef/definition/urn/GroupType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class GroupType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): GroupType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/GroupType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class GroupType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.GROUP], string, exception);
+    }
+    static parse(string) {
+        return new GroupType(string, true);
+    }
+}
+exports.GroupType = GroupType;

package/dist/xiot/core/spec/typedef/definition/urn/PropertyType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class PropertyType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): PropertyType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/PropertyType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class PropertyType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.PROPERTY], string, exception);
+    }
+    static parse(string) {
+        return new PropertyType(string, true);
+    }
+}
+exports.PropertyType = PropertyType;

package/dist/xiot/core/spec/typedef/definition/urn/ServiceType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class ServiceType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): ServiceType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/ServiceType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class ServiceType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.SERVICE], string, exception);
+    }
+    static parse(string) {
+        return new ServiceType(string, true);
+    }
+}
+exports.ServiceType = ServiceType;

package/dist/xiot/core/spec/typedef/definition/urn/UnitType.d.ts

@@ -0,0 +1,5 @@
+import { Urn } from './Urn';
+export declare class UnitType extends Urn {
+    constructor(string: string, exception?: boolean);
+    static parse(string: string): UnitType;
+}

package/dist/xiot/core/spec/typedef/definition/urn/UnitType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitType = void 0;
+const Urn_1 = require("./Urn");
+const UrnType_1 = require("./UrnType");
+class UnitType extends Urn_1.Urn {
+    constructor(string, exception = false) {
+        super([UrnType_1.UrnType.UNIT], string, exception);
+    }
+    static parse(string) {
+        return new UnitType(string, true);
+    }
+}
+exports.UnitType = UnitType;

package/dist/xiot/core/spec/typedef/definition/urn/Urn.d.ts

@@ -0,0 +1,24 @@
+import { UrnType } from './UrnType';
+import { Extendable } from './Extendable';
+import { UrnStyle } from './UrnStyle';
+export declare class Urn extends Extendable {
+    ns: string;
+    type: UrnType;
+    name: string;
+    value: number;
+    v1modified: string;
+    v2modified: string;
+    v2template: string;
+    organization: string;
+    model: string;
+    version: number;
+    style: UrnStyle;
+    valid: boolean;
+    static getShortUUID(value: number, upperCase?: boolean): string;
+    static create(ns: string, type: UrnType, name: string, uuid: string): Urn;
+    constructor(types: UrnType[], string: string, exception?: boolean);
+    private init;
+    private fail;
+    shortUUID(): string;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/definition/urn/Urn.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Urn = void 0;
+const UrnType_1 = require("./UrnType");
+const Extendable_1 = require("./Extendable");
+const UrnStyle_1 = require("./UrnStyle");
+class Urn extends Extendable_1.Extendable {
+    static getShortUUID(value, upperCase = false) {
+        const uuid = upperCase ? value.toString(16).toUpperCase() : value.toString(16).toLowerCase();
+        const length = 8 - uuid.length;
+        let prefix = '';
+        for (let i = 0; i < length; ++i) {
+            prefix += '0';
+        }
+        return prefix + uuid;
+    }
+    static create(ns, type, name, uuid) {
+        const s = `urn:${ns}:${type}:${name}:${uuid}`;
+        return new Urn([type], s);
+    }
+    constructor(types, string, exception = false) {
+        super();
+        this.ns = '';
+        this.type = UrnType_1.UrnType.UNDEFINED;
+        this.name = '';
+        this.value = 0;
+        this.v1modified = '';
+        this.v2modified = '';
+        this.v2template = '';
+        this.organization = '';
+        this.model = '';
+        this.version = 0;
+        this.style = UrnStyle_1.UrnStyle.SPEC;
+        this.valid = true;
+        do {
+            const a = string.split(':');
+            if (a.length < 5) {
+                this.fail(`invalid type: ${string}`, exception);
+                break;
+            }
+            if (!this.init(a[0], a[1], a[2], a[3], a[4])) {
+                this.fail(`invalid type: ${string}`, exception);
+                break;
+            }
+            if (types.indexOf(this.type) < 0) {
+                this.fail(`type not matched: ${string}`, exception);
+                break;
+            }
+            switch (a.length) {
+                // specification type: urn:homekit-spec:device:fan:00000000
+                case 5:
+                    this.style = UrnStyle_1.UrnStyle.SPEC;
+                    break;
+                // v1 instance type => urn:xxx-spec:device:fan:00000000:geek-fff-aaa
+                case 6:
+                    this.style = UrnStyle_1.UrnStyle.V1;
+                    this.v1modified = a[5];
+                    break;
+                // v2 instance type style => urn:xxx-spec:device:fan:00000000:geek-fff-xxf:1
+                case 7:
+                    this.style = UrnStyle_1.UrnStyle.V2;
+                    this.v2modified = a[5];
+                    this.version = Number.parseInt(a[6], 10);
+                    break;
+                case 8:
+                    if (a[7].startsWith('0000')) {
+                        // v2 instance type with template => urn:xxx-spec:device:fan:00000000:geek-fff:1:00008C07
+                        this.style = UrnStyle_1.UrnStyle.V2_TEMPLATE;
+                        this.v2modified = a[5];
+                        this.version = Number.parseInt(a[6], 10);
+                        this.v2template = a[7];
+                    }
+                    else {
+                        // xiot instance type style => urn:homekit-spec:device:fan:00000000:geek:fff:1
+                        this.style = UrnStyle_1.UrnStyle.XIOT;
+                        this.organization = a[5].toLowerCase();
+                        this.model = a[6].toLowerCase();
+                        this.version = Number.parseInt(a[7], 10);
+                        if (this.organization.length === 0) {
+                            this.fail('invalid urn, field: organization is empty', exception);
+                            break;
+                        }
+                        if (this.model.length === 0) {
+                            this.fail('invalid urn, field: model is empty', exception);
+                            break;
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        } while (false);
+    }
+    init(magic, ns, type, name, value) {
+        if (magic !== 'urn') {
+            return false;
+        }
+        if (ns.length === 0) {
+            return false;
+        }
+        if (type.length === 0) {
+            return false;
+        }
+        if (name.length === 0) {
+            return false;
+        }
+        if (value.length === 0) {
+            return false;
+        }
+        this.ns = ns;
+        this.type = (0, UrnType_1.UrnTypeFromString)(type);
+        this.name = name.toLowerCase();
+        this.value = Number.parseInt(value, 16);
+        return this.type !== UrnType_1.UrnType.UNDEFINED;
+    }
+    fail(msg, exception) {
+        if (exception) {
+            throw new Error(msg);
+        }
+        this.valid = false;
+    }
+    shortUUID() {
+        return this.ns.startsWith('miot-spec') ? Urn.getShortUUID(this.value, true) : Urn.getShortUUID(this.value);
+    }
+    toString() {
+        let s = `urn:${this.ns}:${(0, UrnType_1.UrnTypeToString)(this.type)}:${this.name}:${this.shortUUID()}`;
+        switch (this.style) {
+            case UrnStyle_1.UrnStyle.SPEC:
+                break;
+            case UrnStyle_1.UrnStyle.V1:
+                s = `${s}:${this.v1modified}`;
+                break;
+            case UrnStyle_1.UrnStyle.V2:
+                s = `${s}:${this.v2modified}:${this.version}`;
+                break;
+            case UrnStyle_1.UrnStyle.V2_TEMPLATE:
+                s = `${s}:${this.v2modified}:${this.version}:${this.v2template}`;
+                break;
+            case UrnStyle_1.UrnStyle.XIOT:
+                s = `${s}:${this.organization}:${this.model}:${this.version}`;
+                break;
+        }
+        return s;
+    }
+}
+exports.Urn = Urn;

package/dist/xiot/core/spec/typedef/definition/urn/UrnStyle.d.ts

@@ -0,0 +1,7 @@
+export declare enum UrnStyle {
+    SPEC = 0,
+    V1 = 1,
+    V2 = 2,
+    V2_TEMPLATE = 3,
+    XIOT = 4
+}

package/dist/xiot/core/spec/typedef/definition/urn/UrnStyle.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrnStyle = void 0;
+var UrnStyle;
+(function (UrnStyle) {
+    UrnStyle[UrnStyle["SPEC"] = 0] = "SPEC";
+    UrnStyle[UrnStyle["V1"] = 1] = "V1";
+    UrnStyle[UrnStyle["V2"] = 2] = "V2";
+    UrnStyle[UrnStyle["V2_TEMPLATE"] = 3] = "V2_TEMPLATE";
+    UrnStyle[UrnStyle["XIOT"] = 4] = "XIOT";
+})(UrnStyle || (exports.UrnStyle = UrnStyle = {}));

package/dist/xiot/core/spec/typedef/definition/urn/UrnType.d.ts

@@ -0,0 +1,13 @@
+export declare enum UrnType {
+    UNDEFINED = "undefined",
+    PROPERTY = "property",
+    ACTION = "action",
+    EVENT = "event",
+    SERVICE = "service",
+    DEVICE = "device",
+    GROUP = "group",
+    FORMAT = "format",
+    UNIT = "unit"
+}
+export declare function UrnTypeToString(type: UrnType): string;
+export declare function UrnTypeFromString(type: string): UrnType;

package/dist/xiot/core/spec/typedef/definition/urn/UrnType.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrnType = void 0;
+exports.UrnTypeToString = UrnTypeToString;
+exports.UrnTypeFromString = UrnTypeFromString;
+var UrnType;
+(function (UrnType) {
+    UrnType["UNDEFINED"] = "undefined";
+    UrnType["PROPERTY"] = "property";
+    UrnType["ACTION"] = "action";
+    UrnType["EVENT"] = "event";
+    UrnType["SERVICE"] = "service";
+    UrnType["DEVICE"] = "device";
+    UrnType["GROUP"] = "group";
+    UrnType["FORMAT"] = "format";
+    UrnType["UNIT"] = "unit";
+})(UrnType || (exports.UrnType = UrnType = {}));
+function UrnTypeToString(type) {
+    return type.toString();
+}
+function UrnTypeFromString(type) {
+    const keys = Object.keys(UrnType);
+    for (const key of keys) {
+        const s = UrnTypeToString(UrnType[key]);
+        if (s === type) {
+            return UrnType[key];
+        }
+    }
+    return UrnType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/device/Device.d.ts

@@ -0,0 +1,9 @@
+import { Summary } from '../summary/Summary';
+import { Somewhere } from "../somewhere/Somewhere";
+export declare class Device {
+    did: string;
+    summary?: Summary;
+    somewhere?: Somewhere;
+    token?: string;
+    constructor(did: string);
+}

package/dist/xiot/core/spec/typedef/device/Device.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+class Device {
+    constructor(did) {
+        this.did = did;
+    }
+}
+exports.Device = Device;

package/dist/xiot/core/spec/typedef/error/IotError.d.ts

@@ -0,0 +1,5 @@
+export declare class IotError extends Error {
+    status: number;
+    description: string;
+    constructor(status: number, description: string);
+}

package/dist/xiot/core/spec/typedef/error/IotError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IotError = void 0;
+class IotError extends Error {
+    constructor(status, description) {
+        super();
+        this.name = 'IotError';
+        this.status = status;
+        this.description = description;
+        this.message = `${this.name}: {status:${this.status}, description:"${this.description}"}`;
+    }
+}
+exports.IotError = IotError;