@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/utils/TemplateHelper.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateHelper = void 0;
+const UrnStyle_1 = require("../definition/urn/UrnStyle");
+class TemplateHelper {
+    static updateService(service, organizationId, model, version) {
+        if (service.type != null) {
+            service.type.organization = organizationId;
+            service.type.model = model;
+            service.type.version = version;
+            service.type.style = UrnStyle_1.UrnStyle.XIOT;
+            service.getProperties().forEach(p => {
+                return TemplateHelper.updateProperty(p, organizationId, model, version);
+            });
+            service.getActions().forEach(a => {
+                return TemplateHelper.updateAction(a, organizationId, model, version);
+            });
+            service.getEvents().forEach(e => {
+                return TemplateHelper.updateEvent(e, organizationId, model, version);
+            });
+        }
+    }
+    static updateProperty(p, groupId, model, version) {
+        if (p.type != null) {
+            p.type.organization = groupId;
+            p.type.model = model;
+            p.type.version = version;
+            p.type.style = UrnStyle_1.UrnStyle.XIOT;
+        }
+    }
+    static updateAction(a, groupId, model, version) {
+        if (a.type != null) {
+            a.type.organization = groupId;
+            a.type.model = model;
+            a.type.version = version;
+            a.type.style = UrnStyle_1.UrnStyle.XIOT;
+        }
+    }
+    static updateEvent(a, groupId, model, version) {
+        if (a.type != null) {
+            a.type.organization = groupId;
+            a.type.model = model;
+            a.type.version = version;
+            a.type.style = UrnStyle_1.UrnStyle.XIOT;
+        }
+    }
+    static alreadyAddedItems(device) {
+        for (const s of device.getServices()) {
+            if (s.type != null) {
+                if (s.type._just_added) {
+                    return true;
+                }
+            }
+        }
+        for (const s of device.getServices()) {
+            for (const p of s.getProperties()) {
+                if (p.type != null) {
+                    if (p.type._just_added) {
+                        return true;
+                    }
+                }
+            }
+            for (const a of s.getActions()) {
+                if (a.type != null) {
+                    if (a.type._just_added) {
+                        return true;
+                    }
+                }
+            }
+            for (const e of s.getEvents()) {
+                if (e.type != null) {
+                    if (e.type._just_added) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static alreadyChanged(device) {
+        for (const s of device.getServices()) {
+            if (s.type != null) {
+                if (s.type._just_added || s.type._changed) {
+                    return true;
+                }
+            }
+        }
+        for (const s of device.getServices()) {
+            for (const p of s.getProperties()) {
+                if (p.type != null) {
+                    if (p.type._just_added || p.type._changed) {
+                        return true;
+                    }
+                }
+            }
+            for (const a of s.getActions()) {
+                if (a.type != null) {
+                    if (a.type._just_added || a.type._changed) {
+                        return true;
+                    }
+                }
+            }
+            for (const e of s.getEvents()) {
+                if (e.type != null) {
+                    if (e.type._just_added || e.type._changed) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static addServices(device, services) {
+        services.forEach(s => {
+            return TemplateHelper.addService(device, s);
+        });
+    }
+    static addService(device, service) {
+        TemplateHelper.reconstructService(device, service);
+        if (service.type != null) {
+            service.required = false;
+            service.type._just_added = true;
+            service.type._optional = true;
+        }
+        device.services.set(service.iid, service);
+    }
+    static addProperties(device, siid, properties) {
+        properties.forEach(p => {
+            return TemplateHelper.addProperty(device, siid, p);
+        });
+    }
+    static addProperty(device, siid, property) {
+        TemplateHelper.reconstructProperty(device, siid, property);
+        if (property.type != null) {
+            property.required = false;
+            property.type._just_added = true;
+            property.type._optional = true;
+        }
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.properties.set(property.iid, property);
+        }
+    }
+    static addActions(device, siid, actions) {
+        actions.forEach(a => {
+            return TemplateHelper.addAction(device, siid, a);
+        });
+    }
+    static addAction(device, siid, action) {
+        TemplateHelper.reconstructAction(device, siid, action);
+        if (action.type != null) {
+            action.type._just_added = true;
+            action.type._optional = true;
+        }
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.actions.set(action.iid, action);
+        }
+    }
+    static addEvents(device, siid, events) {
+        events.forEach(e => {
+            return TemplateHelper.addEvent(device, siid, e);
+        });
+    }
+    static addEvent(device, siid, event) {
+        TemplateHelper.reconstructEvent(device, siid, event);
+        if (event.type != null) {
+            event.required = false;
+            event.type._just_added = true;
+            event.type._optional = true;
+        }
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.events.set(event.iid, event);
+        }
+    }
+    static reconstructProperty(device, siid, property) {
+        if (device.type == null) {
+            return;
+        }
+        if (device.type.ns === 'homekit-spec') {
+            property.iid = TemplateHelper.newHomeKitIID(device);
+        }
+        else {
+            property.iid = TemplateHelper.newPropertyIID(device, siid);
+        }
+    }
+    static reconstructAction(device, siid, action) {
+        if (device.type == null) {
+            return;
+        }
+        action.iid = TemplateHelper.newActionIID(device, siid);
+    }
+    static reconstructEvent(device, siid, event) {
+        if (device.type == null) {
+            return;
+        }
+        event.iid = TemplateHelper.newEventIID(device, siid);
+    }
+    static reconstructService(device, service) {
+        let piid = 0;
+        if (device.type == null) {
+            return;
+        }
+        if (device.type.ns === 'homekit-spec') {
+            service.iid = TemplateHelper.newHomeKitIID(device);
+            piid = service.iid + 1;
+        }
+        else {
+            service.iid = TemplateHelper.newServiceIID(device);
+            piid = 1;
+        }
+        service.getProperties().forEach(p => {
+            if (p.type != null) {
+                p.type._just_added = true;
+            }
+            p.iid = piid++;
+        });
+        const properties = service.getProperties();
+        service.properties.clear();
+        properties.forEach(p => {
+            return service.properties.set(p.iid, p);
+        });
+    }
+    static newHomeKitIID(device) {
+        let iid = 0;
+        device.getServices().forEach(s => {
+            if (iid < s.iid) {
+                iid = s.iid;
+            }
+            s.getProperties().forEach(p => {
+                if (iid < p.iid) {
+                    iid = p.iid;
+                }
+            });
+        });
+        return iid + 1;
+    }
+    static newServiceIID(device) {
+        let iid = 0;
+        device.getServices().forEach(s => {
+            if (iid < s.iid) {
+                iid = s.iid;
+            }
+        });
+        return iid + 1;
+    }
+    static newPropertyIID(device, siid) {
+        let iid = 0;
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.getProperties().forEach(p => {
+                if (iid < p.iid) {
+                    iid = p.iid;
+                }
+            });
+        }
+        return iid + 1;
+    }
+    static newActionIID(device, siid) {
+        let iid = 0;
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.getActions().forEach(p => {
+                if (iid < p.iid) {
+                    iid = p.iid;
+                }
+            });
+        }
+        return iid + 1;
+    }
+    static newEventIID(device, siid) {
+        let iid = 0;
+        const s = device.services.get(siid);
+        if (s != null) {
+            s.getEvents().forEach(p => {
+                if (iid < p.iid) {
+                    iid = p.iid;
+                }
+            });
+        }
+        return iid + 1;
+    }
+}
+exports.TemplateHelper = TemplateHelper;

package/dist/xiot/core/spec/typedef/version/Version.d.ts

@@ -0,0 +1,9 @@
+export declare class Version {
+    major: number;
+    minor: number;
+    patch: number;
+    constructor(major: number, minor: number, patch: number);
+    static fromString(version: string): Version;
+    toString(): string;
+    greaterThan(other: Version): boolean;
+}

package/dist/xiot/core/spec/typedef/version/Version.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+class Version {
+    constructor(major, minor, patch) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+    static fromString(version) {
+        const s = version.split('.');
+        const x = Number.parseInt(s[0]);
+        const y = Number.parseInt(s[1]);
+        const z = Number.parseInt(s[2]);
+        return new Version(x, y, z);
+    }
+    toString() {
+        return `${this.major}.${this.minor}.${this.patch}`;
+    }
+    greaterThan(other) {
+        if (this.major > other.major) {
+            return true;
+        }
+        else if (this.major === other.major) {
+            if (this.minor > other.minor) {
+                return true;
+            }
+            else if (this.minor === other.minor) {
+                return this.patch > other.patch;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.Version = Version;

package/dist/xiot/core/spec/typedef/xid/ActionID.d.ts

@@ -0,0 +1,13 @@
+import { XID3 } from './XID3';
+export declare class ActionID extends XID3 {
+    /**
+     * 处理ActionId字符串，可能抛异常
+     * @param s
+     */
+    static parse(s: string): ActionID;
+    /**
+     * 创建一个新的ActionId
+     */
+    static create(did: string, siid: number, iid: number): ActionID;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/xid/ActionID.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionID = void 0;
+const XID3_1 = require("./XID3");
+class ActionID extends XID3_1.XID3 {
+    /**
+     * 处理ActionId字符串，可能抛异常
+     * @param s
+     */
+    static parse(s) {
+        return new ActionID(s, true);
+    }
+    /**
+     * 创建一个新的ActionId
+     */
+    static create(did, siid, iid) {
+        const aid = new ActionID();
+        aid.did = did;
+        aid.siid = siid;
+        aid.iid = iid;
+        return aid;
+    }
+    toString() {
+        return super.toString();
+    }
+}
+exports.ActionID = ActionID;

package/dist/xiot/core/spec/typedef/xid/EventID.d.ts

@@ -0,0 +1,6 @@
+import { XID3 } from './XID3';
+export declare class EventID extends XID3 {
+    static parse(s: string): EventID;
+    static create(did: string, siid: number, iid: number): EventID;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/xid/EventID.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventID = void 0;
+const XID3_1 = require("./XID3");
+class EventID extends XID3_1.XID3 {
+    static parse(s) {
+        return new EventID(s, true);
+    }
+    static create(did, siid, iid) {
+        const xid = new EventID();
+        xid.did = did;
+        xid.siid = siid;
+        xid.iid = iid;
+        return xid;
+    }
+    toString() {
+        return super.toString();
+    }
+}
+exports.EventID = EventID;

package/dist/xiot/core/spec/typedef/xid/PropertyID.d.ts

@@ -0,0 +1,6 @@
+import { XID3 } from './XID3';
+export declare class PropertyID extends XID3 {
+    static parse(s: string): PropertyID;
+    static create(did: string, siid: number, iid: number): PropertyID;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/xid/PropertyID.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyID = void 0;
+const XID3_1 = require("./XID3");
+class PropertyID extends XID3_1.XID3 {
+    static parse(s) {
+        return new PropertyID(s, true);
+    }
+    static create(did, siid, iid) {
+        const xid = new PropertyID();
+        xid.did = did;
+        xid.siid = siid;
+        xid.iid = iid;
+        return xid;
+    }
+    toString() {
+        return super.toString();
+    }
+}
+exports.PropertyID = PropertyID;

package/dist/xiot/core/spec/typedef/xid/XID3.d.ts

@@ -0,0 +1,10 @@
+export declare class XID3 {
+    iid: number;
+    siid: number;
+    did: string;
+    valid: boolean;
+    constructor(s?: string, exception?: boolean);
+    parse(value: string, exception?: boolean): void;
+    private fail;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/xid/XID3.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XID3 = void 0;
+class XID3 {
+    constructor(s, exception = false) {
+        this.iid = 0;
+        this.siid = 0;
+        this.did = '';
+        this.valid = true;
+        if (s) {
+            this.parse(s, exception);
+        }
+    }
+    parse(value, exception = false) {
+        if (value == null) {
+            this.fail('value is null', exception);
+        }
+        else {
+            const id = value.split('.');
+            if (id.length !== 3) {
+                this.fail('value invalid', exception);
+            }
+            this.did = id[0];
+            this.siid = Number.parseInt(id[1], 10);
+            this.iid = Number.parseInt(id[2], 10);
+        }
+    }
+    fail(msg, exception) {
+        if (exception) {
+            throw new Error(msg);
+        }
+        this.valid = false;
+    }
+    toString() {
+        if (this.valid) {
+            return `${this.did}.${this.siid}.${this.iid}`;
+        }
+        return '';
+    }
+}
+exports.XID3 = XID3;

package/dist/xiot/core/support/codegen/codec/controlled/ActionControlledCodec.d.ts

@@ -0,0 +1,3 @@
+export declare class ActionControlledCodec {
+    private ActionControlledCodec;
+}

package/dist/xiot/core/support/codegen/codec/controlled/ActionControlledCodec.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionControlledCodec = void 0;
+class ActionControlledCodec {
+    ActionControlledCodec() {
+    }
+}
+exports.ActionControlledCodec = ActionControlledCodec;

package/dist/xiot/core/support/codegen/codec/controlled/DeviceControlledCodec.d.ts

@@ -0,0 +1,3 @@
+export declare class DeviceControlledCodec {
+    private DeviceControlledCodec;
+}

package/dist/xiot/core/support/codegen/codec/controlled/DeviceControlledCodec.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceControlledCodec = void 0;
+class DeviceControlledCodec {
+    DeviceControlledCodec() {
+    }
+}
+exports.DeviceControlledCodec = DeviceControlledCodec;

package/dist/xiot/core/support/codegen/codec/controlled/EventControlledCodec.d.ts

@@ -0,0 +1,3 @@
+export declare class EventControlledCodec {
+    private EventControlledCodec;
+}

package/dist/xiot/core/support/codegen/codec/controlled/EventControlledCodec.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventControlledCodec = void 0;
+class EventControlledCodec {
+    EventControlledCodec() {
+    }
+}
+exports.EventControlledCodec = EventControlledCodec;

package/dist/xiot/core/support/codegen/codec/controlled/PropertyControlledCodec.d.ts

@@ -0,0 +1,3 @@
+export declare class PropertyControlledCodec {
+    private PropertyControlledCodec;
+}

package/dist/xiot/core/support/codegen/codec/controlled/PropertyControlledCodec.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyControlledCodec = void 0;
+class PropertyControlledCodec {
+    PropertyControlledCodec() {
+    }
+}
+exports.PropertyControlledCodec = PropertyControlledCodec;

package/dist/xiot/core/support/codegen/codec/controlled/ServiceControlledCodec.d.ts

@@ -0,0 +1,2 @@
+export declare class ServiceControlledCodec {
+}

package/dist/xiot/core/support/codegen/codec/controlled/ServiceControlledCodec.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceControlledCodec = void 0;
+class ServiceControlledCodec {
+}
+exports.ServiceControlledCodec = ServiceControlledCodec;

package/dist/xiot/core/support/codegen/codec/controller/ActionControllerCodec.d.ts

@@ -0,0 +1,6 @@
+import { ActionController } from "../../typedef/controller/ActionController";
+export declare class ActionControllerCodec {
+    private ActionControllerCodec;
+    private static decodeObject;
+    static decodeArray(array: any[]): ActionController[];
+}

package/dist/xiot/core/support/codegen/codec/controller/ActionControllerCodec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionControllerCodec = void 0;
+const ActionController_1 = require("../../typedef/controller/ActionController");
+const Spec_1 = require("../../../../spec/typedef/constant/Spec");
+const DescriptionCodec_1 = require("../../../../spec/codec/definition/DescriptionCodec");
+const ArgumentCodec_1 = require("../../../../spec/codec/instance/ArgumentCodec");
+const ActionType_1 = require("../../../../spec/typedef/definition/urn/ActionType");
+class ActionControllerCodec {
+    ActionControllerCodec() {
+    }
+    static decodeObject(o) {
+        const iid = o[Spec_1.Spec.IID] || 0;
+        const type = ActionType_1.ActionType.parse(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const argumentsIn = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.IN]);
+        const argumentsOut = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.OUT]);
+        return new ActionController_1.ActionController(iid, type, description, argumentsIn, argumentsOut);
+    }
+    static decodeArray(array) {
+        const actions = [];
+        if (array != null) {
+            for (let item of array) {
+                actions.push(this.decodeObject(item));
+            }
+        }
+        return actions;
+    }
+}
+exports.ActionControllerCodec = ActionControllerCodec;

package/dist/xiot/core/support/codegen/codec/controller/DeviceControllerCodec.d.ts

@@ -0,0 +1,5 @@
+import { DeviceController } from "../../typedef/controller/DeviceController";
+export declare class DeviceControllerCodec {
+    private DeviceControllerCodec;
+    static decode(o: any): DeviceController;
+}

package/dist/xiot/core/support/codegen/codec/controller/DeviceControllerCodec.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceControllerCodec = void 0;
+const DeviceController_1 = require("../../typedef/controller/DeviceController");
+const Spec_1 = require("../../../../spec/typedef/constant/Spec");
+const DescriptionCodec_1 = require("../../../../spec/codec/definition/DescriptionCodec");
+const ServiceControllerCodec_1 = require("./ServiceControllerCodec");
+const UrnType_1 = require("../../../../spec/typedef/definition/urn/UrnType");
+const Urn_1 = require("../../../../spec/typedef/definition/urn/Urn");
+class DeviceControllerCodec {
+    DeviceControllerCodec() {
+    }
+    static decode(o) {
+        const type = new Urn_1.Urn([UrnType_1.UrnType.DEVICE, UrnType_1.UrnType.GROUP], o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const services = ServiceControllerCodec_1.ServiceControllerCodec.decodeArray(o[Spec_1.Spec.SERVICES]);
+        return new DeviceController_1.DeviceController(type, description, services);
+    }
+}
+exports.DeviceControllerCodec = DeviceControllerCodec;

package/dist/xiot/core/support/codegen/codec/controller/EventControllerCodec.d.ts

@@ -0,0 +1,6 @@
+import { EventController } from "../../typedef/controller/EventController";
+export declare class EventControllerCodec {
+    private EventControllerCodec;
+    static decodeObject(o: any): EventController;
+    static decodeArray(array: any[]): EventController[];
+}

package/dist/xiot/core/support/codegen/codec/controller/EventControllerCodec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventControllerCodec = void 0;
+const EventController_1 = require("../../typedef/controller/EventController");
+const Spec_1 = require("../../../../spec/typedef/constant/Spec");
+const EventType_1 = require("../../../../spec/typedef/definition/urn/EventType");
+const DescriptionCodec_1 = require("../../../../spec/codec/definition/DescriptionCodec");
+const ArgumentCodec_1 = require("../../../../spec/codec/instance/ArgumentCodec");
+class EventControllerCodec {
+    EventControllerCodec() {
+    }
+    static decodeObject(o) {
+        const iid = o[Spec_1.Spec.IID] || 0;
+        const type = EventType_1.EventType.parse(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const list = ArgumentCodec_1.ArgumentCodec.decodeArray(o[Spec_1.Spec.ARGUMENTS]);
+        return new EventController_1.EventController(iid, type, description, list);
+    }
+    static decodeArray(array) {
+        const events = [];
+        if (array != null) {
+            for (let item of array) {
+                events.push(EventControllerCodec.decodeObject(item));
+            }
+        }
+        return events;
+    }
+}
+exports.EventControllerCodec = EventControllerCodec;

package/dist/xiot/core/support/codegen/codec/controller/PropertyControllerCodec.d.ts

@@ -0,0 +1,7 @@
+import { PropertyController } from "../../typedef/controller/PropertyController";
+export declare class PropertyControllerCodec {
+    private PropertyControllerCodec;
+    static decodeArray(array: any[]): PropertyController[];
+    private static decodeObject;
+    static encode(property: PropertyController): Object;
+}