@openwebf/webf 0.22.6 → 0.22.8

package/dist/analyzer_original.js

@@ -1,467 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzer = analyzer;
-exports.buildClassRelationship = buildClassRelationship;
-const typescript_1 = __importStar(require("typescript"));
-const declaration_1 = require("./declaration");
-const utils_1 = require("./utils");
-function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
-    const sourceFile = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
-    blob.objects = sourceFile.statements.map(statement => walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector)).filter(o => {
-        return o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject;
-    });
-}
-function buildClassRelationship() {
-    const globalClassMap = declaration_1.ClassObject.globalClassMap;
-    const globalClassRelationMap = declaration_1.ClassObject.globalClassRelationMap;
-    Object.values(globalClassMap).forEach(obj => {
-        if (obj.parent) {
-            globalClassRelationMap[obj.parent] = globalClassRelationMap[obj.parent] || [];
-            globalClassRelationMap[obj.parent].push(obj.name);
-        }
-    });
-}
-function getInterfaceName(statement) {
-    return statement.name.escapedText;
-}
-function getHeritageType(heritage) {
-    let expression = heritage.types[0].expression;
-    if (expression.kind === typescript_1.default.SyntaxKind.Identifier) {
-        return expression.escapedText;
-    }
-    return null;
-}
-function getMixins(hertage) {
-    if (hertage.types.length <= 1)
-        return null;
-    let mixins = [];
-    hertage.types.slice(1).forEach(types => {
-        let expression = types.expression;
-        if (expression.kind === typescript_1.default.SyntaxKind.Identifier) {
-            mixins.push(expression.escapedText);
-        }
-    });
-    return mixins;
-}
-function getPropName(propName, prop) {
-    if (propName.kind == typescript_1.default.SyntaxKind.Identifier) {
-        return propName.escapedText.toString();
-    }
-    else if (propName.kind === typescript_1.default.SyntaxKind.StringLiteral) {
-        return propName.text;
-    }
-    else if (propName.kind === typescript_1.default.SyntaxKind.NumericLiteral) {
-        return propName.text;
-        // @ts-ignore
-    }
-    else if (propName.kind === typescript_1.default.SyntaxKind.ComputedPropertyName && propName.expression.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
-        prop.isSymbol = true;
-        // @ts-ignore
-        let expression = propName.expression;
-        // @ts-ignore
-        return `${expression.expression.text}_${expression.name.text}`;
-    }
-    throw new Error(`prop name: ${typescript_1.default.SyntaxKind[propName.kind]} is not supported`);
-}
-function getParameterName(name) {
-    if (name.kind === typescript_1.default.SyntaxKind.Identifier) {
-        return name.escapedText.toString();
-    }
-    return '';
-}
-function getParameterBaseType(type, mode) {
-    if (type.kind === typescript_1.default.SyntaxKind.StringKeyword) {
-        return declaration_1.FunctionArgumentType.dom_string;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.NumberKeyword) {
-        return declaration_1.FunctionArgumentType.double;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.BooleanKeyword) {
-        return declaration_1.FunctionArgumentType.boolean;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.AnyKeyword) {
-        return declaration_1.FunctionArgumentType.any;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.ObjectKeyword) {
-        return declaration_1.FunctionArgumentType.object;
-        // @ts-ignore
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.VoidKeyword) {
-        return declaration_1.FunctionArgumentType.void;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.NullKeyword) {
-        return declaration_1.FunctionArgumentType.null;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.UndefinedKeyword) {
-        return declaration_1.FunctionArgumentType.undefined;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.TypeReference) {
-        let typeReference = type;
-        // @ts-ignore
-        let identifier = typeReference.typeName.text;
-        if (identifier === 'Function') {
-            return declaration_1.FunctionArgumentType.function;
-        }
-        else if (identifier === 'Promise') {
-            return declaration_1.FunctionArgumentType.promise;
-        }
-        else if (identifier === 'JSArrayProtoMethod') {
-            return declaration_1.FunctionArgumentType.js_array_proto_methods;
-        }
-        else if (identifier === 'int') {
-            return declaration_1.FunctionArgumentType.int;
-        }
-        else if (identifier === 'double') {
-            return declaration_1.FunctionArgumentType.double;
-        }
-        else if (identifier === 'NewObject') {
-            if (mode)
-                mode.newObject = true;
-            let argument = typeReference.typeArguments[0];
-            // @ts-ignore
-            return argument.typeName.text;
-        }
-        else if (identifier === 'DartImpl') {
-            if (mode)
-                mode.dartImpl = true;
-            let argument = typeReference.typeArguments[0];
-            if (argument.kind == typescript_1.default.SyntaxKind.TypeReference) {
-                let typeReference = argument;
-                // @ts-ignore
-                let identifier = typeReference.typeName.text;
-                if (identifier == 'DependentsOnLayout') {
-                    if (mode) {
-                        mode.layoutDependent = true;
-                    }
-                    argument = typeReference.typeArguments[0];
-                }
-            }
-            // @ts-ignore
-            return getParameterBaseType(argument);
-        }
-        else if (identifier == 'DependentsOnLayout') {
-            if (mode)
-                mode.layoutDependent = true;
-            let argument = typeReference.typeArguments[0];
-            argument = typeReference.typeArguments[0];
-            // @ts-ignore
-            return getParameterBaseType(argument);
-        }
-        else if (identifier === 'StaticMember') {
-            if (mode)
-                mode.static = true;
-            let argument = typeReference.typeArguments[0];
-            // @ts-ignore
-            return getParameterBaseType(argument);
-        }
-        else if (identifier === 'StaticMethod') {
-            if (mode)
-                mode.staticMethod = true;
-            let argument = typeReference.typeArguments[0];
-            // @ts-ignore
-            return getParameterBaseType(argument);
-        }
-        else if (identifier.indexOf('SupportAsync') >= 0) {
-            if (mode) {
-                mode.supportAsync = true;
-                if (identifier === "SupportAsyncManual") {
-                    mode.supportAsyncManual = true;
-                }
-            }
-            let argument = typeReference.typeArguments[0];
-            if (argument.kind == typescript_1.default.SyntaxKind.TypeReference) {
-                let typeReference = argument;
-                // @ts-ignore
-                let identifier = typeReference.typeName.text;
-                if (identifier == 'DartImpl') {
-                    if (mode) {
-                        mode.dartImpl = true;
-                    }
-                    argument = typeReference.typeArguments[0];
-                }
-            }
-            else if (argument.kind == typescript_1.default.SyntaxKind.ArrayType) {
-                let elementType = argument.elementType;
-                if (mode)
-                    mode.supportAsyncArrayValue = true;
-                return getParameterBaseType(elementType);
-            }
-            // @ts-ignore
-            return getParameterBaseType(argument);
-        }
-        return identifier;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.LiteralType) {
-        // @ts-ignore
-        return getParameterBaseType(type.literal, mode);
-    }
-    return declaration_1.FunctionArgumentType.any;
-}
-function getParameterType(type, unionTypeCollector, mode) {
-    if (type.kind === typescript_1.default.SyntaxKind.ParenthesizedType) {
-        let typeNode = type;
-        return getParameterType(typeNode.type, unionTypeCollector, mode);
-    }
-    if (type.kind == typescript_1.default.SyntaxKind.ArrayType) {
-        let arrayType = type;
-        return {
-            isArray: true,
-            value: getParameterType(arrayType.elementType, unionTypeCollector, mode)
-        };
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.UnionType) {
-        let node = type;
-        let types = node.types;
-        let result = {
-            isArray: false,
-            value: types.map(type => getParameterType(type, unionTypeCollector, mode))
-        };
-        if ((0, utils_1.isUnionType)(result)) {
-            unionTypeCollector.types.add(result.value);
-        }
-        return result;
-    }
-    else if (type.kind === typescript_1.default.SyntaxKind.TypeReference) {
-        let typeReference = type;
-        // @ts-ignore
-        let identifier = typeReference.typeName.text;
-        if (identifier.indexOf('SupportAsync') >= 0) {
-            let argument = typeReference.typeArguments[0];
-            if (argument.kind == typescript_1.default.SyntaxKind.UnionType) {
-                if (mode) {
-                    mode.supportAsync = true;
-                    if (identifier === 'SupportAsyncManual') {
-                        mode.supportAsyncManual = true;
-                    }
-                }
-                let node = argument;
-                let types = node.types;
-                let result = {
-                    isArray: false,
-                    value: types.map(type => getParameterType(type, unionTypeCollector, mode))
-                };
-                if ((0, utils_1.isUnionType)(result)) {
-                    unionTypeCollector.types.add(result.value);
-                }
-                return result;
-            }
-        }
-    }
-    return {
-        isArray: false,
-        value: getParameterBaseType(type, mode)
-    };
-}
-function paramsNodeToArguments(parameter, unionTypeCollector) {
-    let args = new declaration_1.FunctionArguments();
-    args.name = getParameterName(parameter.name);
-    let typeMode = new declaration_1.ParameterMode();
-    args.type = getParameterType(parameter.type, unionTypeCollector, typeMode);
-    args.isDotDotDot = !!parameter.dotDotDotToken;
-    args.typeMode = typeMode;
-    args.required = !parameter.questionToken;
-    return args;
-}
-function isParamsReadOnly(m) {
-    if (!m.modifiers)
-        return false;
-    return m.modifiers.some(k => k.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
-}
-function walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector) {
-    switch (statement.kind) {
-        case typescript_1.default.SyntaxKind.InterfaceDeclaration: {
-            let interfaceName = getInterfaceName(statement);
-            let s = statement;
-            let obj = new declaration_1.ClassObject();
-            let constructorDefined = false;
-            if (s.heritageClauses) {
-                let heritage = s.heritageClauses[0];
-                let heritageType = getHeritageType(heritage);
-                let mixins = getMixins(heritage);
-                if (heritageType)
-                    obj.parent = heritageType.toString();
-                if (mixins)
-                    obj.mixinParent = mixins;
-            }
-            obj.name = s.name.escapedText.toString();
-            if (obj.kind === declaration_1.ClassObjectKind.interface) {
-                definedPropertyCollector.interfaces.add('QJS' + interfaceName);
-                definedPropertyCollector.files.add(blob.filename);
-                definedPropertyCollector.properties.add(interfaceName);
-            }
-            s.members.forEach(member => {
-                var _a;
-                switch (member.kind) {
-                    case typescript_1.default.SyntaxKind.PropertySignature: {
-                        let prop = new declaration_1.PropsDeclaration();
-                        let m = member;
-                        prop.name = getPropName(m.name, prop);
-                        prop.readonly = isParamsReadOnly(m);
-                        definedPropertyCollector.properties.add(prop.name);
-                        let propKind = m.type;
-                        if (propKind) {
-                            let mode = new declaration_1.ParameterMode();
-                            prop.type = getParameterType(propKind, unionTypeCollector, mode);
-                            prop.typeMode = mode;
-                            if (member.questionToken) {
-                                prop.optional = true;
-                            }
-                            if (prop.type.value === declaration_1.FunctionArgumentType.function) {
-                                let f = m.type;
-                                let functionProps = prop;
-                                functionProps.args = [];
-                                f.parameters.forEach(params => {
-                                    let p = paramsNodeToArguments(params, unionTypeCollector);
-                                    functionProps.args.push(p);
-                                });
-                                obj.methods.push(functionProps);
-                            }
-                            else {
-                                obj.props.push(prop);
-                                if (prop.typeMode.supportAsync) {
-                                    // keep asyncProp supportAsync = true
-                                    let asyncProp = Object.assign({}, prop);
-                                    // set prop supportAsync = false
-                                    let syncMode = Object.assign({}, mode);
-                                    syncMode.supportAsync = false;
-                                    mode.supportAsyncManual = false;
-                                    prop.typeMode = syncMode;
-                                    asyncProp.name = asyncProp.name + '_async';
-                                    definedPropertyCollector.properties.add(asyncProp.name);
-                                    asyncProp.async_type = {
-                                        isArray: false,
-                                        value: declaration_1.FunctionArgumentType.promise
-                                    };
-                                    obj.props.push(asyncProp);
-                                }
-                            }
-                        }
-                        break;
-                    }
-                    case typescript_1.default.SyntaxKind.MethodSignature: {
-                        let m = member;
-                        let f = new declaration_1.FunctionDeclaration();
-                        f.name = getPropName(m.name);
-                        f.args = [];
-                        m.parameters.forEach(params => {
-                            let p = paramsNodeToArguments(params, unionTypeCollector);
-                            f.args.push(p);
-                        });
-                        obj.methods.push(f);
-                        if (m.type) {
-                            let mode = new declaration_1.ParameterMode();
-                            f.returnType = getParameterType(m.type, unionTypeCollector, mode);
-                            // Override the default type for SupportAsync<Type[]> to support ArrayTypes;
-                            if (mode.supportAsyncArrayValue) {
-                                f.returnType = {
-                                    isArray: true,
-                                    value: f.returnType
-                                };
-                            }
-                            f.returnTypeMode = mode;
-                            if (f.returnTypeMode.staticMethod) {
-                                obj.staticMethods.push(f);
-                            }
-                        }
-                        if ((_a = f.returnTypeMode) === null || _a === void 0 ? void 0 : _a.supportAsync) {
-                            // keep asyncFunc supportAsync = true
-                            let asyncFunc = Object.assign({}, f);
-                            let mode = Object.assign({}, f.returnTypeMode);
-                            mode.supportAsync = false;
-                            mode.supportAsyncManual = false;
-                            f.returnTypeMode = mode;
-                            asyncFunc.name = getPropName(m.name) + '_async';
-                            asyncFunc.args = [];
-                            m.parameters.forEach(params => {
-                                let p = paramsNodeToArguments(params, unionTypeCollector);
-                                asyncFunc.args.push(p);
-                            });
-                            asyncFunc.async_returnType = {
-                                isArray: false,
-                                value: declaration_1.FunctionArgumentType.promise
-                            };
-                            obj.methods.push(asyncFunc);
-                        }
-                        break;
-                    }
-                    case typescript_1.default.SyntaxKind.IndexSignature: {
-                        let m = member;
-                        let prop = new declaration_1.IndexedPropertyDeclaration();
-                        let modifier = m.modifiers;
-                        prop.readonly = !!(modifier && modifier[0].kind == typescript_1.default.SyntaxKind.ReadonlyKeyword);
-                        let params = m.parameters;
-                        prop.indexKeyType = params[0].type.kind === typescript_1.default.SyntaxKind.NumberKeyword ? 'number' : 'string';
-                        let mode = new declaration_1.ParameterMode();
-                        prop.type = getParameterType(m.type, unionTypeCollector, mode);
-                        prop.typeMode = mode;
-                        obj.indexedProp = prop;
-                        break;
-                    }
-                    case typescript_1.default.SyntaxKind.ConstructSignature: {
-                        let m = member;
-                        let c = new declaration_1.FunctionDeclaration();
-                        c.name = 'constructor';
-                        c.args = [];
-                        m.parameters.forEach(params => {
-                            let p = paramsNodeToArguments(params, unionTypeCollector);
-                            c.args.push(p);
-                        });
-                        c.returnType = getParameterType(m.type, unionTypeCollector);
-                        obj.construct = c;
-                        constructorDefined = true;
-                        break;
-                    }
-                }
-            });
-            declaration_1.ClassObject.globalClassMap[interfaceName] = obj;
-            return obj;
-        }
-        case typescript_1.default.SyntaxKind.VariableStatement: {
-            let declaration = statement.declarationList.declarations[0];
-            let methodName = declaration.name.text;
-            let type = declaration.type;
-            let functionObject = new declaration_1.FunctionObject();
-            functionObject.declare = new declaration_1.FunctionDeclaration();
-            if ((type === null || type === void 0 ? void 0 : type.kind) == typescript_1.default.SyntaxKind.FunctionType) {
-                functionObject.declare.args = type.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
-                functionObject.declare.returnType = getParameterType(type.type, unionTypeCollector);
-                functionObject.declare.name = methodName.toString();
-            }
-            return functionObject;
-        }
-    }
-    return null;
-}