@ibyar/expressions 0.5.0 → 0.5.4

package/api/class/class.js

@@ -0,0 +1,594 @@
+var Super_1, MetaProperty_1, PrivateIdentifier_1, StaticBlock_1, MethodDefinition_1, PropertyDefinition_1, AccessorProperty_1, ClassBody_1, ClassDeclaration_1, ClassExpression_1;
+import { __decorate as __decorate_1, __metadata } from "tslib";
+import { __decorate } from 'tslib';
+import { AbstractExpressionNode } from '../abstract.js';
+import { Deserializer } from '../deserialize/deserialize.js';
+import { Identifier } from '../definition/values.js';
+import { MemberExpression } from '../definition/member.js';
+import { FunctionExpression } from '../definition/function.js';
+import { BlockStatement } from '../statement/control/block.js';
+import { CallExpression } from '../computing/call.js';
+const TEMP_CLASS_NAME = Symbol('temp_class_name');
+const SUPER = Symbol('super');
+const NEW_TARGET = Symbol('new.target');
+const IMPORT_META = Symbol('import.meta');
+const STACK = Symbol('stack');
+const GET_PARAMETERS = Symbol('getParameters');
+const GET_SUPER_PROPERTY = Symbol('getSuperProperty');
+const CALL_SUPER_Method = Symbol('callSuperMethod');
+const CONSTRUCTOR = Symbol('constructor');
+const PRIVATE_SYMBOL = Symbol('#private');
+const INIT_PRIVATE_SYMBOL = Symbol('#init_private');
+const STATIC_INITIALIZATION_BLOCK = Symbol('static_block');
+let Super = Super_1 = class Super extends AbstractExpressionNode {
+    constructor() {
+        super();
+    }
+    static fromJSON(node) {
+        return Super_1.INSTANCE;
+    }
+    shareVariables(scopeList) { }
+    set(stack, value) {
+        throw new Error('Super.#set() Method not implemented.');
+    }
+    get(stack, thisContext) {
+        throw new Error('Super.#get() Method not implemented.');
+    }
+    dependency(computed) {
+        throw new Error('Super.#dependency() Method not implemented.');
+    }
+    dependencyPath(computed) {
+        throw new Error('Super.#dependencyPath() Method not implemented.');
+    }
+    toString() {
+        return `super`;
+    }
+    toJson() {
+        return {};
+    }
+};
+Super.INSTANCE = new Super_1();
+Super = Super_1 = __decorate_1([
+    Deserializer('Super'),
+    __metadata("design:paramtypes", [])
+], Super);
+export { Super };
+let MetaProperty = MetaProperty_1 = class MetaProperty extends MemberExpression {
+    constructor(meta, property) {
+        super(meta, property, false);
+        this.meta = meta;
+    }
+    static getJsonName(identifier) {
+        return Reflect.get(identifier, 'name');
+    }
+    static fromJSON(node, deserializer) {
+        if (MetaProperty_1.getJsonName(node.meta) === 'new' && MetaProperty_1.getJsonName(node.property) === 'target') {
+            return MetaProperty_1.NewTarget;
+        }
+        else if (MetaProperty_1.getJsonName(node.meta) === 'import' && MetaProperty_1.getJsonName(node.property) === 'meta') {
+            return MetaProperty_1.ImportMeta;
+        }
+        return new MetaProperty_1(deserializer(node.meta), deserializer(node.property));
+    }
+    static visit(node, visitNode) {
+        visitNode(node.meta);
+        visitNode(node.property);
+    }
+    getMeta() {
+        return this.meta;
+    }
+    shareVariables(scopeList) { }
+    get(stack, thisContext) {
+        if (MetaProperty_1.getJsonName(this.meta) === 'new' && MetaProperty_1.getJsonName(this.property) === 'target') {
+            return stack.get(NEW_TARGET);
+        }
+        else if (MetaProperty_1.getJsonName(this.meta) === 'import' && MetaProperty_1.getJsonName(this.property) === 'meta') {
+            const importObject = stack.getModule()?.get('import');
+            return importObject['meta'];
+        }
+        return super.get(stack, thisContext);
+    }
+    toString() {
+        return `${this.meta.toString()}.${this.property.toString()}`;
+    }
+    toJson() {
+        return {
+            meta: this.meta.toJSON(),
+            property: this.property.toJSON(),
+        };
+    }
+};
+MetaProperty.NewTarget = new MetaProperty_1(new Identifier('new'), new Identifier('target'));
+MetaProperty.ImportMeta = new MetaProperty_1(new Identifier('import'), new Identifier('meta'));
+MetaProperty = MetaProperty_1 = __decorate_1([
+    Deserializer('MetaProperty'),
+    __metadata("design:paramtypes", [Identifier, Identifier])
+], MetaProperty);
+export { MetaProperty };
+let PrivateIdentifier = PrivateIdentifier_1 = class PrivateIdentifier extends AbstractExpressionNode {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    static fromJSON(node) {
+        return new PrivateIdentifier_1(node.name);
+    }
+    getName() {
+        return this.name;
+    }
+    set(stack, value) {
+        const privateScope = stack.findScope(PRIVATE_SYMBOL);
+        privateScope.getScope(PRIVATE_SYMBOL)?.set(this.name, value);
+    }
+    get(stack, thisContext) {
+        const privateObj = stack.get(PRIVATE_SYMBOL);
+        return privateObj[this.name];
+    }
+    dependency(computed) {
+        return [];
+    }
+    dependencyPath(computed) {
+        return [];
+    }
+    shareVariables(scopeList) { }
+    toString() {
+        return `#${this.name}`;
+    }
+    toJson() {
+        return {
+            name: this.name
+        };
+    }
+};
+PrivateIdentifier = PrivateIdentifier_1 = __decorate_1([
+    Deserializer('PrivateIdentifier'),
+    __metadata("design:paramtypes", [String])
+], PrivateIdentifier);
+export { PrivateIdentifier };
+let StaticBlock = StaticBlock_1 = class StaticBlock extends BlockStatement {
+    static fromJSON(node, deserializer) {
+        return new StaticBlock_1(deserializer(node.body), node.isStatement);
+    }
+    constructor(body, isStatement) {
+        super(body, isStatement);
+    }
+    get(stack, classConstructor) {
+        const constructor = classConstructor;
+        constructor[STATIC_INITIALIZATION_BLOCK].push(() => super.get(stack));
+    }
+    toString() {
+        return `static ${super.toString()}`;
+    }
+};
+StaticBlock = StaticBlock_1 = __decorate_1([
+    Deserializer('StaticBlock'),
+    __metadata("design:paramtypes", [Array, Boolean])
+], StaticBlock);
+export { StaticBlock };
+export class AbstractDefinition extends AbstractExpressionNode {
+    constructor(key, decorators, computed, isStatic, value) {
+        super();
+        this.key = key;
+        this.decorators = decorators;
+        this.computed = computed;
+        this.value = value;
+        this.static = isStatic;
+    }
+    getKey() {
+        return this.key;
+    }
+    getValue() {
+        return this.value;
+    }
+    isComputed() {
+        return this.computed;
+    }
+    isStatic() {
+        return this.static;
+    }
+    getDecorators() {
+        return this.decorators;
+    }
+    shareVariables(scopeList) { }
+    set(stack, value) {
+        throw new Error('AbstractDefinition.#set() Method not implemented.');
+    }
+    dependency(computed) {
+        return [];
+    }
+    dependencyPath(computed) {
+        return [];
+    }
+}
+let MethodDefinition = MethodDefinition_1 = class MethodDefinition extends AbstractDefinition {
+    constructor(kind, key, value, decorators, computed, isStatic) {
+        super(key, decorators, computed, isStatic, value);
+        this.kind = kind;
+    }
+    static fromJSON(node, deserializer) {
+        return new MethodDefinition_1(node.kind, deserializer(node.key), deserializer(node.value), node.decorators.map(deserializer), node.computed, node.static);
+    }
+    static visit(node, visitNode) {
+        visitNode(node.key);
+        visitNode(node.value);
+        node.decorators.forEach(visitNode);
+    }
+    getKind() {
+        return this.kind;
+    }
+    getValue() {
+        return this.value;
+    }
+    get(stack, classConstructor) {
+        if (this.kind === 'constructor') {
+            this.initConstructor(stack, classConstructor);
+            return;
+        }
+        const target = this.static ? classConstructor : classConstructor.prototype;
+        const value = this.value?.get(stack);
+        const name = this.computed ? this.key.get(stack) : this.key.getName();
+        const ref = this.key instanceof PrivateIdentifier ? target[INIT_PRIVATE_SYMBOL] : target;
+        switch (this.kind) {
+            case 'method':
+                ref[name] = value;
+                break;
+            case 'set':
+                Object.defineProperty(ref, name, {
+                    configurable: true,
+                    enumerable: false,
+                    set: value,
+                });
+                break;
+            case 'get':
+                Object.defineProperty(ref, name, {
+                    configurable: true,
+                    enumerable: false,
+                    get: value,
+                });
+                break;
+            default:
+                break;
+        }
+        const decorators = this.decorators.map(decorator => decorator.get(stack));
+        __decorate(decorators, target, name, null);
+    }
+    initConstructor(stack, classConstructor) {
+        let superIndex = this.value.getBody()
+            .findIndex(call => call instanceof CallExpression && Super.INSTANCE === call.getCallee());
+        if (superIndex === -1) {
+            superIndex = this.value.getBody().length;
+        }
+        const superCall = this.value.getBody()[superIndex];
+        const blockBeforeSuper = new BlockStatement(this.value.getBody().slice(0, superIndex), false);
+        const blockAfterSuper = new BlockStatement(this.value.getBody().slice(superIndex + 1), false);
+        if (superCall) {
+            classConstructor[GET_PARAMETERS] = function (params) {
+                const scope = stack.pushBlockScope();
+                this.value.setParameter(stack, params);
+                blockBeforeSuper.get(stack);
+                const parameters = superCall.getCallParameters(stack);
+                stack.clearTo(scope);
+                return parameters;
+            };
+        }
+        classConstructor.prototype[CONSTRUCTOR] = function (params) {
+            const scope = this[STACK].pushBlockScope();
+            blockAfterSuper.get(this[STACK]);
+            stack.clearTo(scope);
+        };
+    }
+    toString() {
+        let str = this.decorators.map(decorator => decorator.toString()).join(' ');
+        if (str.length) {
+            str += ' ';
+        }
+        let name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
+        switch (this.kind) {
+            case 'constructor':
+                str += 'constructor ';
+                break;
+            case 'get':
+                str += `get ${name} `;
+                break;
+            case 'set':
+                str += `set ${name} `;
+                break;
+            default:
+                str = `${name} `;
+                break;
+        }
+        str += this.value.toString();
+        return str;
+    }
+    toJson() {
+        return {
+            kind: this.kind,
+            key: this.key.toJSON(),
+            value: this.value.toJSON(),
+            decorators: this.decorators.map(decorator => decorator.toJSON()),
+            computed: this.computed,
+            static: this.static,
+        };
+    }
+};
+MethodDefinition = MethodDefinition_1 = __decorate_1([
+    Deserializer('MethodDefinition'),
+    __metadata("design:paramtypes", [String, Object, FunctionExpression, Array, Boolean, Boolean])
+], MethodDefinition);
+export { MethodDefinition };
+let PropertyDefinition = PropertyDefinition_1 = class PropertyDefinition extends AbstractDefinition {
+    static fromJSON(node, deserializer) {
+        return new PropertyDefinition_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value && deserializer(node.value));
+    }
+    static visit(node, visitNode) {
+        visitNode(node.key);
+        node.value && visitNode(node.value);
+    }
+    constructor(key, decorators, computed, isStatic, value) {
+        super(key, decorators, computed, isStatic, value);
+    }
+    get(stack, classConstructor) {
+        const target = this.static ? classConstructor : classConstructor.prototype;
+        const value = this.value?.get(stack);
+        const name = this.computed ? this.key.get(stack) : this.key.getName();
+        const ref = this.key instanceof PrivateIdentifier ? target[INIT_PRIVATE_SYMBOL] : target;
+        ref[name] = value;
+        const decorators = this.decorators.map(decorator => decorator.get(stack));
+        __decorate(decorators, target, name, null);
+    }
+    toString() {
+        const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
+        const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
+        if (this.value) {
+            return `${name} = ${this.value.toString()};`;
+        }
+        return `${decorators.length ? decorators + ' ' : ''}${name};`;
+    }
+    toJson() {
+        return {
+            key: this.key.toJSON(),
+            value: this.value?.toJSON(),
+            decorators: this.decorators.map(decorator => decorator.toJSON()),
+            computed: this.computed,
+            static: this.static,
+        };
+    }
+};
+PropertyDefinition = PropertyDefinition_1 = __decorate_1([
+    Deserializer('PropertyDefinition'),
+    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object])
+], PropertyDefinition);
+export { PropertyDefinition };
+let AccessorProperty = AccessorProperty_1 = class AccessorProperty extends AbstractDefinition {
+    static fromJSON(node, deserializer) {
+        return new AccessorProperty_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value ? deserializer(node.value) : void 0);
+    }
+    static visit(node, visitNode) {
+        visitNode(node.key);
+        node.value && visitNode(node.value);
+        node.decorators.forEach(visitNode);
+    }
+    constructor(key, decorators, computed, isStatic, value) {
+        super(key, decorators, computed, isStatic, value);
+    }
+    get(stack, classConstructor) {
+        const target = this.static ? classConstructor : classConstructor.prototype;
+        const value = this.value?.get(stack);
+        const name = this.computed ? this.key.get(stack) : this.key.getName();
+        target[INIT_PRIVATE_SYMBOL][name] = value;
+        Object.defineProperty(target, name, {
+            configurable: true,
+            enumerable: false,
+            set: function (setValue) {
+                this[PRIVATE_SYMBOL][name] = setValue;
+            },
+        });
+        Object.defineProperty(target, name, {
+            configurable: true,
+            enumerable: false,
+            get: function () {
+                return this[PRIVATE_SYMBOL][name];
+            },
+        });
+        const decorators = this.decorators.map(decorator => decorator.get(stack));
+        __decorate(decorators, target, name, null);
+    }
+    toString() {
+        const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
+        const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
+        if (this.value) {
+            return `${name} = ${this.value.toString()};`;
+        }
+        return `${decorators.length ? decorators + ' ' : ''}accessor ${name};`;
+    }
+    toJson() {
+        return {
+            key: this.key.toJSON(),
+            decorators: this.decorators.map(decorator => decorator.toJSON()),
+            computed: this.computed,
+            static: this.static,
+            value: this.value?.toJSON(),
+        };
+    }
+};
+AccessorProperty = AccessorProperty_1 = __decorate_1([
+    Deserializer('AccessorProperty'),
+    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object])
+], AccessorProperty);
+export { AccessorProperty };
+let ClassBody = ClassBody_1 = class ClassBody extends AbstractExpressionNode {
+    constructor(body) {
+        super();
+        this.body = body;
+    }
+    static fromJSON(node, deserializer) {
+        return new ClassBody_1(node.body.map(deserializer));
+    }
+    static visit(node, visitNode) {
+        node.body.forEach(visitNode);
+    }
+    getBody() {
+        return this.body;
+    }
+    shareVariables(scopeList) { }
+    set(stack, value) {
+        throw new Error('Method not implemented.');
+    }
+    get(stack, classConstructor) {
+        this.body.forEach(definition => definition.get(stack, classConstructor));
+    }
+    dependency(computed) {
+        throw new Error('Method not implemented.');
+    }
+    dependencyPath(computed) {
+        throw new Error('Method not implemented.');
+    }
+    toString() {
+        return this.body.map(definition => definition.toString()).join('\n');
+    }
+    toJson() {
+        return {
+            body: this.body.map(method => method.toJSON())
+        };
+    }
+};
+ClassBody = ClassBody_1 = __decorate_1([
+    Deserializer('ClassBody'),
+    __metadata("design:paramtypes", [Array])
+], ClassBody);
+export { ClassBody };
+export class Class extends AbstractExpressionNode {
+    constructor(body, decorators, id, superClass) {
+        super();
+        this.body = body;
+        this.decorators = decorators;
+        this.id = id;
+        this.superClass = superClass;
+    }
+    getBody() {
+        return this.body;
+    }
+    getDecorators() {
+        return this.decorators;
+    }
+    getId() {
+        return this.id;
+    }
+    getSuperClass() {
+        return this.superClass;
+    }
+    shareVariables(scopeList) {
+        this.sharedVariables = scopeList;
+    }
+    set(stack) {
+        throw new Error(`Class.#set() has no implementation.`);
+    }
+    get(stack) {
+        const className = this.id?.get(stack);
+        const parentClass = this.superClass?.get(stack) ?? class {
+        };
+        let classConstructor = this.createClass(stack, parentClass, className);
+        this.body.get(stack, classConstructor);
+        classConstructor[PRIVATE_SYMBOL] = Object.assign(classConstructor[PRIVATE_SYMBOL], classConstructor[INIT_PRIVATE_SYMBOL]);
+        Reflect.deleteProperty(classConstructor, INIT_PRIVATE_SYMBOL);
+        const decorators = this.decorators.map(decorator => decorator.get(stack));
+        classConstructor = __decorate(decorators, classConstructor);
+        return classConstructor;
+    }
+    createClass(stack, parentClass, className = TEMP_CLASS_NAME) {
+        var _a, _b, _c, _d, _e, _f;
+        const TEMP = {
+            [className]: (_a = class extends parentClass {
+                    constructor(...params) {
+                        const parameters = TEMP[className][GET_PARAMETERS](params);
+                        super(...parameters);
+                        this[_e] = {};
+                        this[_f] = {};
+                        this[PRIVATE_SYMBOL] = Object.assign(this[PRIVATE_SYMBOL], this[INIT_PRIVATE_SYMBOL]);
+                        this[STACK] = stack.copyStack();
+                        const instanceStack = this[STACK];
+                        instanceStack.pushBlockScope();
+                        instanceStack.declareVariable('this', this);
+                        instanceStack.declareVariable(NEW_TARGET, new.target);
+                        instanceStack.declareVariable(PRIVATE_SYMBOL, this[PRIVATE_SYMBOL]);
+                        instanceStack.declareVariable(CALL_SUPER_Method, (name) => super[name]());
+                        instanceStack.declareVariable(GET_SUPER_PROPERTY, (name) => super[name]);
+                        instanceStack.pushReactiveScope();
+                        this[CONSTRUCTOR]();
+                    }
+                    static [GET_PARAMETERS](args) {
+                        return [];
+                    }
+                    [(_b = STATIC_INITIALIZATION_BLOCK, _c = INIT_PRIVATE_SYMBOL, _d = PRIVATE_SYMBOL, _e = PRIVATE_SYMBOL, _f = INIT_PRIVATE_SYMBOL, CONSTRUCTOR)]() { }
+                },
+                _a[_b] = [],
+                _a[_c] = {},
+                _a[_d] = {},
+                (() => {
+                    _a[STATIC_INITIALIZATION_BLOCK].forEach(block => block());
+                })(),
+                _a)
+        };
+        return TEMP[className];
+    }
+    dependency(computed) {
+        throw new Error('Method not implemented.');
+    }
+    dependencyPath(computed) {
+        throw new Error('Method not implemented.');
+    }
+    toString() {
+        const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
+        let classDeclaration = 'class ';
+        if (this.id) {
+            classDeclaration += this.id.toString();
+        }
+        if (this.superClass) {
+            classDeclaration += ' extends ' + this.superClass.toString();
+        }
+        return `${decorators}${classDeclaration} {${this.body.toString()}\n`;
+    }
+    toJson() {
+        return {
+            body: this.body.toJSON(),
+            decorators: this.decorators.map(decorator => decorator.toJSON()),
+            id: this.id?.toJSON(),
+            superClass: this.superClass?.toJSON(),
+        };
+    }
+}
+let ClassDeclaration = ClassDeclaration_1 = class ClassDeclaration extends Class {
+    static fromJSON(node, deserializer) {
+        return new ClassDeclaration_1(deserializer(node.body), deserializer(node.id), node.superClass && deserializer(node.superClass));
+    }
+    static visit(node, visitNode) {
+        visitNode(node.body);
+        node.id && visitNode(node.id);
+        node.superClass && visitNode(node.superClass);
+    }
+    declareVariable(stack, propertyValue) {
+        this.id && stack.declareVariable(this.id.getName(), propertyValue);
+    }
+    getDeclarationName() {
+        return this.id?.getDeclarationName();
+    }
+};
+ClassDeclaration = ClassDeclaration_1 = __decorate_1([
+    Deserializer('ClassDeclaration')
+], ClassDeclaration);
+export { ClassDeclaration };
+let ClassExpression = ClassExpression_1 = class ClassExpression extends Class {
+    static fromJSON(node, deserializer) {
+        return new ClassExpression_1(deserializer(node.body), node.id && deserializer(node.id), node.superClass && deserializer(node.superClass));
+    }
+    static visit(node, visitNode) {
+        visitNode(node.body);
+        node.id && visitNode(node.id);
+        node.superClass && visitNode(node.superClass);
+    }
+};
+ClassExpression = ClassExpression_1 = __decorate_1([
+    Deserializer('ClassExpression')
+], ClassExpression);
+export { ClassExpression };
+//# sourceMappingURL=class.js.map