@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/parser/token/Tokenizer.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokenizer = void 0;
+const Token_1 = require("./Token");
+class Tokenizer {
+    constructor() {
+        this.tokens = [];
+        this.bytes = [];
+        this.current = 0;
+    }
+    parse(expression) {
+        this.tokens = [];
+        this.bytes = expression.split('');
+        while (this.current < this.bytes.length) {
+            this.parseToken();
+        }
+        return this.tokens;
+    }
+    parseToken() {
+        switch (this.bytes[this.current]) {
+            case ' ':
+            case '\n':
+            case '\r':
+            case '\t':
+                this.current++;
+                break;
+            case '(':
+                this.parseTokenMonocase(Token_1.TokenType.LEFT_PARENTHESES);
+                break;
+            case ')':
+                this.parseTokenMonocase(Token_1.TokenType.RIGHT_PARENTHESES);
+                break;
+            case '{':
+                this.parseTokenMonocase(Token_1.TokenType.LEFT_BRACE);
+                break;
+            case '}':
+                this.parseTokenMonocase(Token_1.TokenType.RIGHT_BRACE);
+                break;
+            case '#':
+                this.parseTokenMonocase(Token_1.TokenType.HASH);
+                break;
+            case ',':
+                this.parseTokenMonocase(Token_1.TokenType.COMMA);
+                break;
+            case ';':
+                this.parseTokenMonocase(Token_1.TokenType.SEMICOLON);
+                break;
+            case '@':
+                this.parseTokenExternalID();
+                break;
+            case 't':
+                this.parseTokenTrue();
+                break;
+            case 'f':
+                this.parseTokenFalse();
+                break;
+            case 'I':
+                this.parseTokenIF();
+                break;
+            case 'T':
+                this.parseTokenTHEN();
+                break;
+            case 'E':
+                this.parseTokenENDIF();
+                break;
+            case 'S':
+                this.parseTokenSLEEP();
+                break;
+            case 'R':
+                this.parseTokenREMIND_or_REVERSE();
+                break;
+            case 'A':
+                this.parseTokenAND_or_ANY_AUTOSCALING();
+                break;
+            case '"':
+                this.parseTokenString();
+                break;
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                this.parseTokenNumber();
+                break;
+            case '&':
+                this.parseTokeAnd(); // &&
+                break;
+            case '|':
+                this.parseTokenOR(); // ||
+                break;
+            case '!':
+                this.parseTokenNOT_or_NOT_EQUAL(); // ! or !=
+                break;
+            case '=':
+                this.parseTokenEQUAL_or_ASSIGNMENT_or_OPERATE(); // ==, =>, =
+                break;
+            case '>':
+                this.parseTokenGreater_or_GE(); // > or >=
+                break;
+            case '<':
+                this.parseTokenLess_or_LE(); // < or <=
+                break;
+            default:
+                this.parseTokenID3();
+                break;
+        }
+    }
+    parseTokenMonocase(type) {
+        this.tokens.push(new Token_1.Token(type, this.current, 1, this.bytes));
+        this.current++;
+    }
+    parseTokenTrue() {
+        if (this.bytes[this.current] !== 't' || this.bytes[this.current + 1] !== 'r'
+            || this.bytes[this.current + 2] !== 'u' || this.bytes[this.current + 3] !== 'e') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.TRUE, this.current, 4, this.bytes));
+        this.current += 4;
+    }
+    parseTokenFalse() {
+        if (this.bytes[this.current] !== 'f'
+            || this.bytes[this.current + 1] !== 'a'
+            || this.bytes[this.current + 2] !== 'l'
+            || this.bytes[this.current + 3] !== 's'
+            || this.bytes[this.current + 4] !== 'e') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.FALSE, this.current, 5, this.bytes));
+        this.current += 5;
+    }
+    parseTokenIF() {
+        if (this.bytes[this.current] !== 'I' || this.bytes[this.current + 1] !== 'F') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_IF, this.current, 2, this.bytes));
+        this.current += 2;
+    }
+    parseTokenTHEN() {
+        if (this.bytes[this.current] !== 'T'
+            || this.bytes[this.current + 1] !== 'H'
+            || this.bytes[this.current + 2] !== 'E'
+            || this.bytes[this.current + 3] !== 'N') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_THEN, this.current, 4, this.bytes));
+        this.current += 4;
+    }
+    parseTokenENDIF() {
+        if (this.bytes[this.current] !== 'E'
+            || this.bytes[this.current + 1] !== 'N'
+            || this.bytes[this.current + 2] !== 'D'
+            || this.bytes[this.current + 3] !== 'I'
+            || this.bytes[this.current + 4] !== 'F') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_ENDIF, this.current, 5, this.bytes));
+        this.current += 5;
+    }
+    parseTokenSLEEP() {
+        if (this.bytes[this.current] !== 'S'
+            || this.bytes[this.current + 1] !== 'L'
+            || this.bytes[this.current + 2] !== 'E'
+            || this.bytes[this.current + 3] !== 'E'
+            || this.bytes[this.current + 4] !== 'P') {
+            this.parseTokenID3();
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_SLEEP, this.current, 5, this.bytes));
+        this.current += 5;
+    }
+    parseTokenREMIND_or_REVERSE() {
+        if (this.bytes[this.current] !== 'R' || this.bytes[this.current + 1] !== 'E') {
+            this.parseTokenID3();
+            return;
+        }
+        // RE + MIND
+        if (this.bytes[this.current + 2] === 'M'
+            && this.bytes[this.current + 3] === 'I'
+            && this.bytes[this.current + 4] === 'N'
+            && this.bytes[this.current + 5] === 'D') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_REMIND, this.current, 6, this.bytes));
+            this.current += 6;
+            return;
+        }
+        // RE + VERSE
+        if (this.bytes[this.current + 2] === 'V'
+            && this.bytes[this.current + 3] === 'E'
+            && this.bytes[this.current + 4] === 'R'
+            && this.bytes[this.current + 5] === 'S'
+            && this.bytes[this.current + 6] === 'E') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_REVERSE, this.current, 7, this.bytes));
+            this.current += 7;
+            return;
+        }
+        this.parseTokenID3();
+    }
+    parseTokenAND_or_ANY_AUTOSCALING() {
+        if (this.bytes[this.current] !== 'A') {
+            this.parseTokenID3();
+            return;
+        }
+        // A + ND
+        if (this.bytes[this.current + 1] === 'N' && this.bytes[this.current + 2] === 'D') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_AND, this.current, 3, this.bytes));
+            this.current += 3;
+            return;
+        }
+        // A + NY
+        if (this.bytes[this.current + 1] === 'N' && this.bytes[this.current + 2] === 'Y') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_ANY, this.current, 3, this.bytes));
+            this.current += 3;
+            return;
+        }
+        // A + UTOSCALING
+        if (this.bytes[this.current + 1] === 'U'
+            && this.bytes[this.current + 2] === 'T'
+            && this.bytes[this.current + 3] === 'O'
+            && this.bytes[this.current + 4] === 'S'
+            && this.bytes[this.current + 5] === 'C'
+            && this.bytes[this.current + 6] === 'A'
+            && this.bytes[this.current + 7] === 'L'
+            && this.bytes[this.current + 8] === 'I'
+            && this.bytes[this.current + 9] === 'N'
+            && this.bytes[this.current + 10] === 'G') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.KEY_AUTOSCALING, this.current, 11, this.bytes));
+            this.current += 11;
+            return;
+        }
+        this.parseTokenID3();
+    }
+    parseTokenString() {
+        do {
+            // 去掉左引号"
+            const offset = this.current + 1;
+            this.current++;
+            while (true) {
+                let c = this.bytes[this.current];
+                if (c === '\\') {
+                    c = this.bytes[this.current];
+                    this.current++;
+                    switch (c) {
+                        case '"':
+                        case '\\':
+                        case '/':
+                        case 'b':
+                        case 'f':
+                        case 'n':
+                        case 'r':
+                        case 't':
+                            this.current++;
+                            break;
+                        case 'u':
+                            this.current++;
+                            if (this.is_hex(this.bytes[this.current]) &&
+                                this.is_hex(this.bytes[this.current + 1]) &&
+                                this.is_hex(this.bytes[this.current + 2]) &&
+                                this.is_hex(this.bytes[this.current + 3])) {
+                                this.current += 4;
+                            }
+                            else {
+                                throw new Error(`String invalid, this.current:
+               ${this.current} => ${this.bytes[this.current]}${this.bytes[this.current + 2]}${this.bytes[this.current + 3]}`);
+                            }
+                            break;
+                        default:
+                            throw new Error(`String invalid, this.current: ${this.current} => ${c}`);
+                    }
+                }
+                else if (c === '"') {
+                    this.current++;
+                    break;
+                }
+                else if (this.is_print(c)) {
+                    this.current++;
+                }
+                else {
+                    throw new Error(`String invalid, this.current: ${this.current} => ${c}`);
+                }
+            }
+            // 去掉右引号, length - 1
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.STRING, offset, this.current - offset - 1, this.bytes));
+        } while (false);
+    }
+    parseTokenNumber() {
+        do {
+            const offset = this.current;
+            let c = this.bytes[this.current];
+            do {
+                if (c === '-') {
+                    this.current++;
+                }
+                if (this.current >= this.bytes.length) {
+                    throw new Error(`Number invalid, this.current: ${this.current} => ${c}`);
+                }
+                c = this.bytes[this.current];
+                if (c === '0') {
+                    this.current++;
+                }
+                else if (c >= '1' && c <= '9') {
+                    this.current++;
+                    while (this.current < this.bytes.length) {
+                        c = this.bytes[this.current];
+                        if (!/^\d$/.test(c)) {
+                            break;
+                        }
+                        this.current++;
+                    }
+                }
+                else {
+                    throw new Error(`Number invalid, this.current: ${this.current} => ${c}`);
+                }
+                if (this.current >= this.bytes.length) {
+                    break;
+                }
+                c = this.bytes[this.current];
+                if (c === '.') {
+                    this.current++;
+                    while (this.current < this.bytes.length) {
+                        c = this.bytes[this.current];
+                        if (!/^\d$/.test(c)) {
+                            break;
+                        }
+                        this.current++;
+                    }
+                }
+                if (this.current >= this.bytes.length) {
+                    break;
+                }
+                if (c === ' '
+                    || c === '\r'
+                    || c === '\n'
+                    || c === '\t'
+                    || c === '}'
+                    || c === ']'
+                    || c === ','
+                    || c === ')'
+                    || c === '='
+                    || c === ';') {
+                    break;
+                }
+                else {
+                    // 123456.1.1 结构，不应该识别为浮点数，应该尝试用ID的方式去识别
+                    this.current = offset;
+                    this.parseTokenID3();
+                    return;
+                }
+            } while (false);
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.NUMBER, offset, this.current - offset, this.bytes));
+        } while (false);
+    }
+    parseTokeAnd() {
+        // &&
+        if (this.bytes[this.current + 1] !== '&') {
+            throw new Error(`AND operator invalid: ${this.bytes[this.current]}${this.bytes[this.current + 1]}`);
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_AND, this.current, 2, this.bytes));
+        this.current += 2;
+    }
+    parseTokenOR() {
+        // ||
+        if (this.bytes[this.current + 1] !== '|') {
+            throw new Error(`OR operator invalid: ${this.bytes[this.current]}${this.bytes[this.current + 1]}`);
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_OR, this.current, 2, this.bytes));
+        this.current += 2;
+    }
+    parseTokenNOT_or_NOT_EQUAL() {
+        // !=
+        if (this.bytes[this.current + 1] !== '=') {
+            throw new Error(`!= operator invalid: ${this.bytes[this.current]}${this.bytes[this.current + 1]}`);
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_NOT_EQUAL, this.current, 2, this.bytes));
+        this.current += 2;
+    }
+    //
+    parseTokenEQUAL_or_ASSIGNMENT_or_OPERATE() {
+        // ==
+        if (this.bytes[this.current + 1] === '=') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_EQUAL, this.current, 2, this.bytes));
+            this.current += 2;
+            return;
+        }
+        if (this.bytes[this.current + 1] === '>') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OPERATE, this.current, 2, this.bytes));
+            this.current += 2;
+            return;
+        }
+        this.tokens.push(new Token_1.Token(Token_1.TokenType.ASSIGNMENT, this.current, 1, this.bytes));
+        this.current += 1;
+    }
+    parseTokenGreater_or_GE() {
+        // >=
+        if (this.bytes[this.current + 1] === '=') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_GREATER_OR_EQUAL, this.current, 2, this.bytes));
+            this.current += 2;
+        }
+        else {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_GREATER, this.current, 1, this.bytes));
+            this.current++;
+        }
+    }
+    parseTokenLess_or_LE() {
+        // <=
+        if (this.bytes[this.current + 1] === '=') {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_LESS_OR_EQUAL, this.current, 2, this.bytes));
+            this.current += 2;
+        }
+        else {
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.OP_LESS, this.current, 1, this.bytes));
+            this.current++;
+        }
+    }
+    parseTokenExternalID() {
+        do {
+            let offset = this.current;
+            while (true) {
+                const c = this.bytes[this.current];
+                if (c === ' ' || c === '=' || c === '<' || c === '>' || c === '!' || c === ')' || c === ';' || c === '\n' || c === '\r') {
+                    break;
+                }
+                if ((c >= 'a' && c <= 'z')
+                    || (c >= 'A' && c <= 'Z')
+                    || (c >= '0' && c <= '9')
+                    || c === '@'
+                    || c === '-'
+                    || c === '.') {
+                    this.current++;
+                }
+                else {
+                    throw new Error(`external ID invalid, ID: ${this.current} => ${c}`);
+                }
+            }
+            // skip '@'
+            if ((this.current - offset) > 0) {
+                offset++;
+            }
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.EXID, offset, this.current - offset, this.bytes));
+        } while (false);
+    }
+    parseTokenID3() {
+        do {
+            const offset = this.current;
+            while (true) {
+                const c = this.bytes[this.current];
+                if (c === ' ' || c === '=' || c === '<' || c === '>' || c === '!' || c === ')') {
+                    break;
+                }
+                if ((c >= 'a' && c <= 'z')
+                    || (c >= 'A' && c <= 'Z')
+                    || (c >= '0' && c <= '9')
+                    || c === '@'
+                    || c === '-'
+                    || c === '.') {
+                    this.current++;
+                }
+                else {
+                    throw new Error(`ID invalid, ID: ${this.current} => ${c}`);
+                }
+            }
+            this.tokens.push(new Token_1.Token(Token_1.TokenType.XID3, offset, this.current - offset, this.bytes));
+        } while (false);
+    }
+    is_hex(c) {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+    }
+    is_print(b) {
+        return /^[0-9a-zA-Z]*$/.test(b)
+            || /\s*/.test(b) || /\n*/.test(b)
+            || b === '*' || b === ',' || b === '?' || b === '-' || b === ':';
+    }
+}
+exports.Tokenizer = Tokenizer;

package/dist/xiot/core/spec/typedef/shadow/DeviceShadow.d.ts

@@ -0,0 +1,5 @@
+import { Shadow } from './Shadow';
+export declare class DeviceShadow {
+    did: string;
+    shadows: Shadow[];
+}

package/dist/xiot/core/spec/typedef/shadow/DeviceShadow.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceShadow = void 0;
+class DeviceShadow {
+    constructor() {
+        this.did = '';
+        this.shadows = [];
+    }
+}
+exports.DeviceShadow = DeviceShadow;

package/dist/xiot/core/spec/typedef/shadow/Shadow.d.ts

@@ -0,0 +1,7 @@
+export declare class Shadow {
+    siid: number;
+    piid: number;
+    value: any;
+    status: number;
+    description: string;
+}

package/dist/xiot/core/spec/typedef/shadow/Shadow.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shadow = void 0;
+class Shadow {
+    constructor() {
+        this.siid = 0;
+        this.piid = 0;
+        this.value = {};
+        this.status = 0;
+        this.description = '';
+    }
+}
+exports.Shadow = Shadow;

package/dist/xiot/core/spec/typedef/somewhere/Somewhere.d.ts

@@ -0,0 +1,11 @@
+import { Where } from "./Where";
+export declare class Somewhere {
+    where: Where;
+    spaceId: string;
+    index: number;
+    local(): boolean;
+    cloud(): boolean;
+    protected changeWhere(where: Where): boolean;
+    protected changeSpaceId(spaceId: string): boolean;
+    protected changeIndex(index: number): boolean;
+}

package/dist/xiot/core/spec/typedef/somewhere/Somewhere.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Somewhere = void 0;
+const Where_1 = require("./Where");
+class Somewhere {
+    constructor() {
+        this.where = Where_1.Where.UNKNOWN;
+        this.spaceId = '';
+        this.index = 0;
+    }
+    local() {
+        if (this.where != null) {
+            return this.where == Where_1.Where.LOCAL || this.where == Where_1.Where.LOCAL_AND_CLOUD;
+        }
+        return false;
+    }
+    cloud() {
+        if (this.where != null) {
+            return this.where == Where_1.Where.CLOUD || this.where == Where_1.Where.LOCAL_AND_CLOUD;
+        }
+        return false;
+    }
+    changeWhere(where) {
+        if (this.where === where) {
+            return false;
+        }
+        this.where = where;
+        return true;
+    }
+    changeSpaceId(spaceId) {
+        if (this.spaceId === spaceId) {
+            return false;
+        }
+        this.spaceId = spaceId;
+        return true;
+    }
+    changeIndex(index) {
+        if (this.index === index) {
+            return false;
+        }
+        this.index = index;
+        return true;
+    }
+}
+exports.Somewhere = Somewhere;

package/dist/xiot/core/spec/typedef/somewhere/Where.d.ts

@@ -0,0 +1,9 @@
+export declare enum Where {
+    UNKNOWN = "unknown",
+    LOCAL = "local",
+    CLUSTER = "cluster",
+    CLOUD = "cloud",
+    LOCAL_AND_CLOUD = "local-and-cloud"
+}
+export declare function WhereToString(x: Where): string;
+export declare function WhereFromString(type: string): Where;

package/dist/xiot/core/spec/typedef/somewhere/Where.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Where = void 0;
+exports.WhereToString = WhereToString;
+exports.WhereFromString = WhereFromString;
+var Where;
+(function (Where) {
+    Where["UNKNOWN"] = "unknown";
+    Where["LOCAL"] = "local";
+    Where["CLUSTER"] = "cluster";
+    Where["CLOUD"] = "cloud";
+    Where["LOCAL_AND_CLOUD"] = "local-and-cloud";
+})(Where || (exports.Where = Where = {}));
+function WhereToString(x) {
+    return x.toString();
+}
+function WhereFromString(type) {
+    const keys = Object.keys(Where);
+    for (const key of keys) {
+        const s = WhereToString(Where[key]);
+        if (s === type) {
+            return Where[key];
+        }
+    }
+    return Where.UNKNOWN;
+}

package/dist/xiot/core/spec/typedef/space/Space.d.ts

@@ -0,0 +1,9 @@
+export declare class Space {
+    id: string;
+    name: string;
+    rootId: string | null;
+    parentId: string | null;
+    index: number;
+    constructor(id: string);
+    isRoot(): boolean;
+}

package/dist/xiot/core/spec/typedef/space/Space.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Space = void 0;
+class Space {
+    constructor(id) {
+        this.id = '';
+        this.name = '';
+        this.rootId = null;
+        this.parentId = null;
+        this.index = 0;
+        this.id = id;
+    }
+    isRoot() {
+        if (this.rootId !== null) {
+            return this.rootId === this.id;
+        }
+        return this.parentId === null;
+    }
+}
+exports.Space = Space;

package/dist/xiot/core/spec/typedef/status/AbstractStatus.d.ts

@@ -0,0 +1,8 @@
+export declare class AbstractStatus {
+    status: number;
+    description: string;
+    isError(): boolean;
+    isNotError(): boolean;
+    isCompleted(): boolean;
+    isNotCompleted(): boolean;
+}

package/dist/xiot/core/spec/typedef/status/AbstractStatus.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractStatus = void 0;
+const Status_1 = require("./Status");
+class AbstractStatus {
+    constructor() {
+        this.status = Status_1.Status.COMPLETED;
+        this.description = '';
+    }
+    isError() {
+        return (this.status < 0);
+    }
+    isNotError() {
+        return (this.status >= 0);
+    }
+    isCompleted() {
+        return (this.status == 0);
+    }
+    isNotCompleted() {
+        return (this.status == Status_1.Status.TO_BE_EXECUTE);
+    }
+}
+exports.AbstractStatus = AbstractStatus;