@openwebf/webf 0.22.3 → 0.22.4

package/dist/IDLBlob.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDLBlob = void 0;
+class IDLBlob {
+    constructor(source, dist, filename, implement, relativeDir = '') {
+        this.raw = '';
+        this.relativeDir = '';
+        this.objects = [];
+        this.source = source;
+        this.dist = dist;
+        this.filename = filename;
+        this.implement = implement;
+        this.relativeDir = relativeDir;
+        // Don't read file in constructor - let the generator handle it
+    }
+}
+exports.IDLBlob = IDLBlob;

package/dist/analyzer.js

@@ -0,0 +1,578 @@
+"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;
+exports.clearCaches = clearCaches;
+const typescript_1 = __importStar(require("typescript"));
+const declaration_1 = require("./declaration");
+const utils_1 = require("./utils");
+// Cache for parsed source files to avoid re-parsing
+const sourceFileCache = new Map();
+// Cache for type conversions to avoid redundant processing
+const typeConversionCache = new Map();
+// Type mapping constants for better performance
+const BASIC_TYPE_MAP = {
+    [typescript_1.default.SyntaxKind.StringKeyword]: declaration_1.FunctionArgumentType.dom_string,
+    [typescript_1.default.SyntaxKind.NumberKeyword]: declaration_1.FunctionArgumentType.double,
+    [typescript_1.default.SyntaxKind.BooleanKeyword]: declaration_1.FunctionArgumentType.boolean,
+    [typescript_1.default.SyntaxKind.AnyKeyword]: declaration_1.FunctionArgumentType.any,
+    [typescript_1.default.SyntaxKind.ObjectKeyword]: declaration_1.FunctionArgumentType.object,
+    [typescript_1.default.SyntaxKind.VoidKeyword]: declaration_1.FunctionArgumentType.void,
+    [typescript_1.default.SyntaxKind.NullKeyword]: declaration_1.FunctionArgumentType.null,
+    [typescript_1.default.SyntaxKind.UndefinedKeyword]: declaration_1.FunctionArgumentType.undefined,
+};
+const TYPE_REFERENCE_MAP = {
+    'Function': declaration_1.FunctionArgumentType.function,
+    'Promise': declaration_1.FunctionArgumentType.promise,
+    'JSArrayProtoMethod': declaration_1.FunctionArgumentType.js_array_proto_methods,
+    'int': declaration_1.FunctionArgumentType.int,
+    'double': declaration_1.FunctionArgumentType.double,
+};
+function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
+    try {
+        // Check cache first
+        let sourceFile = sourceFileCache.get(blob.source);
+        if (!sourceFile) {
+            sourceFile = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
+            sourceFileCache.set(blob.source, sourceFile);
+        }
+        blob.objects = sourceFile.statements
+            .map(statement => {
+            try {
+                return walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector);
+            }
+            catch (error) {
+                console.error(`Error processing statement in ${blob.source}:`, error);
+                return null;
+            }
+        })
+            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject);
+    }
+    catch (error) {
+        console.error(`Error analyzing ${blob.source}:`, error);
+        throw new Error(`Failed to analyze ${blob.source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function buildClassRelationship() {
+    const globalClassMap = declaration_1.ClassObject.globalClassMap;
+    const globalClassRelationMap = declaration_1.ClassObject.globalClassRelationMap;
+    // Use more efficient for...in loop
+    for (const key in globalClassMap) {
+        const obj = globalClassMap[key];
+        if (obj.parent) {
+            if (!globalClassRelationMap[obj.parent]) {
+                globalClassRelationMap[obj.parent] = [];
+            }
+            globalClassRelationMap[obj.parent].push(obj.name);
+        }
+    }
+}
+function getInterfaceName(statement) {
+    if (!typescript_1.default.isInterfaceDeclaration(statement)) {
+        throw new Error('Statement is not an interface declaration');
+    }
+    return statement.name.escapedText;
+}
+function getHeritageType(heritage) {
+    if (!heritage.types.length)
+        return null;
+    const expression = heritage.types[0].expression;
+    if (typescript_1.default.isIdentifier(expression)) {
+        return expression.escapedText;
+    }
+    return null;
+}
+function getMixins(heritage) {
+    if (heritage.types.length <= 1)
+        return null;
+    const mixins = [];
+    for (let i = 1; i < heritage.types.length; i++) {
+        const expression = heritage.types[i].expression;
+        if (typescript_1.default.isIdentifier(expression)) {
+            mixins.push(expression.escapedText);
+        }
+    }
+    return mixins.length > 0 ? mixins : null;
+}
+function getPropName(propName, prop) {
+    switch (propName.kind) {
+        case typescript_1.default.SyntaxKind.Identifier:
+            return propName.escapedText.toString();
+        case typescript_1.default.SyntaxKind.StringLiteral:
+            return propName.text;
+        case typescript_1.default.SyntaxKind.NumericLiteral:
+            return propName.text;
+        case typescript_1.default.SyntaxKind.ComputedPropertyName:
+            if (typescript_1.default.isPropertyAccessExpression(propName.expression)) {
+                if (prop)
+                    prop.isSymbol = true;
+                const expression = propName.expression;
+                return `${expression.expression.getText()}_${expression.name.getText()}`;
+            }
+            throw new Error(`Computed property name of type ${typescript_1.default.SyntaxKind[propName.expression.kind]} is not supported`);
+        default:
+            throw new Error(`Property name of type ${typescript_1.default.SyntaxKind[propName.kind]} is not supported`);
+    }
+}
+function getParameterName(name) {
+    if (typescript_1.default.isIdentifier(name)) {
+        return name.escapedText.toString();
+    }
+    // Handle other binding patterns if needed
+    console.warn('Non-identifier parameter names are not fully supported');
+    return '';
+}
+function getParameterBaseType(type, mode) {
+    // Check basic types first (most common case)
+    const basicType = BASIC_TYPE_MAP[type.kind];
+    if (basicType !== undefined) {
+        return basicType;
+    }
+    if (type.kind === typescript_1.default.SyntaxKind.TypeReference) {
+        const typeReference = type;
+        const typeName = typeReference.typeName;
+        if (!typescript_1.default.isIdentifier(typeName)) {
+            console.warn('Non-identifier type references are not supported');
+            return declaration_1.FunctionArgumentType.any;
+        }
+        const identifier = typeName.text;
+        // Check simple type references
+        const mappedType = TYPE_REFERENCE_MAP[identifier];
+        if (mappedType !== undefined) {
+            return mappedType;
+        }
+        // Handle special type wrappers
+        switch (identifier) {
+            case 'NewObject':
+                if (mode)
+                    mode.newObject = true;
+                if (typeReference.typeArguments && typeReference.typeArguments[0]) {
+                    const argument = typeReference.typeArguments[0];
+                    if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
+                        return argument.typeName.text;
+                    }
+                }
+                return declaration_1.FunctionArgumentType.any;
+            case 'DartImpl':
+                if (mode)
+                    mode.dartImpl = true;
+                return handleDartImplType(typeReference, mode);
+            case 'DependentsOnLayout':
+                if (mode)
+                    mode.layoutDependent = true;
+                return handleDependentsOnLayoutType(typeReference, mode);
+            case 'StaticMember':
+                if (mode)
+                    mode.static = true;
+                return handleGenericWrapper(typeReference, mode);
+            case 'StaticMethod':
+                if (mode)
+                    mode.staticMethod = true;
+                return handleGenericWrapper(typeReference, mode);
+            default:
+                if (identifier.includes('SupportAsync')) {
+                    return handleSupportAsyncType(identifier, typeReference, mode);
+                }
+                return identifier;
+        }
+    }
+    if (type.kind === typescript_1.default.SyntaxKind.LiteralType) {
+        // Handle literal types - check if it's a null literal
+        const literalType = type;
+        if (literalType.literal.kind === typescript_1.default.SyntaxKind.NullKeyword) {
+            return declaration_1.FunctionArgumentType.null;
+        }
+        return declaration_1.FunctionArgumentType.any;
+    }
+    return declaration_1.FunctionArgumentType.any;
+}
+function handleDartImplType(typeReference, mode) {
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return declaration_1.FunctionArgumentType.any;
+    }
+    let argument = typeReference.typeArguments[0];
+    if (typescript_1.default.isTypeReferenceNode(argument)) {
+        const typeName = argument.typeName;
+        if (typescript_1.default.isIdentifier(typeName) && typeName.text === 'DependentsOnLayout') {
+            if (mode)
+                mode.layoutDependent = true;
+            if (argument.typeArguments && argument.typeArguments[0]) {
+                argument = argument.typeArguments[0];
+            }
+        }
+    }
+    return getParameterBaseType(argument, mode);
+}
+function handleDependentsOnLayoutType(typeReference, mode) {
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return declaration_1.FunctionArgumentType.any;
+    }
+    const argument = typeReference.typeArguments[0];
+    return getParameterBaseType(argument, mode);
+}
+function handleGenericWrapper(typeReference, mode) {
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return declaration_1.FunctionArgumentType.any;
+    }
+    const argument = typeReference.typeArguments[0];
+    return getParameterBaseType(argument, mode);
+}
+function handleSupportAsyncType(identifier, typeReference, mode) {
+    if (mode) {
+        mode.supportAsync = true;
+        if (identifier === "SupportAsyncManual") {
+            mode.supportAsyncManual = true;
+        }
+    }
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return declaration_1.FunctionArgumentType.any;
+    }
+    let argument = typeReference.typeArguments[0];
+    if (typescript_1.default.isTypeReferenceNode(argument)) {
+        const typeName = argument.typeName;
+        if (typescript_1.default.isIdentifier(typeName) && typeName.text === 'DartImpl') {
+            if (mode)
+                mode.dartImpl = true;
+            if (argument.typeArguments && argument.typeArguments[0]) {
+                argument = argument.typeArguments[0];
+            }
+        }
+    }
+    else if (typescript_1.default.isArrayTypeNode(argument)) {
+        if (mode)
+            mode.supportAsyncArrayValue = true;
+        return getParameterBaseType(argument.elementType, mode);
+    }
+    return getParameterBaseType(argument, mode);
+}
+function getParameterType(type, unionTypeCollector, mode) {
+    // Generate cache key
+    const cacheKey = `${type.kind}_${type.pos}_${type.end}`;
+    // Check cache first (only for types without mode)
+    if (!mode) {
+        const cached = typeConversionCache.get(cacheKey);
+        if (cached)
+            return cached;
+    }
+    let result;
+    if (type.kind === typescript_1.default.SyntaxKind.ParenthesizedType) {
+        const typeNode = type;
+        result = getParameterType(typeNode.type, unionTypeCollector, mode);
+    }
+    else if (type.kind === typescript_1.default.SyntaxKind.ArrayType) {
+        const arrayType = type;
+        result = {
+            isArray: true,
+            value: getParameterType(arrayType.elementType, unionTypeCollector, mode)
+        };
+    }
+    else if (type.kind === typescript_1.default.SyntaxKind.UnionType) {
+        const unionType = type;
+        const types = unionType.types.map(t => getParameterType(t, unionTypeCollector, mode));
+        result = {
+            isArray: false,
+            value: types
+        };
+        if ((0, utils_1.isUnionType)(result)) {
+            unionTypeCollector.types.add(result.value);
+        }
+    }
+    else if (type.kind === typescript_1.default.SyntaxKind.TypeReference) {
+        result = handleTypeReferenceForParameter(type, unionTypeCollector, mode);
+    }
+    else {
+        result = {
+            isArray: false,
+            value: getParameterBaseType(type, mode)
+        };
+    }
+    // Cache the result if no mode
+    if (!mode) {
+        typeConversionCache.set(cacheKey, result);
+    }
+    return result;
+}
+function handleTypeReferenceForParameter(typeReference, unionTypeCollector, mode) {
+    const typeName = typeReference.typeName;
+    if (!typescript_1.default.isIdentifier(typeName)) {
+        return {
+            isArray: false,
+            value: declaration_1.FunctionArgumentType.any
+        };
+    }
+    const identifier = typeName.text;
+    if (identifier.includes('SupportAsync') && typeReference.typeArguments && typeReference.typeArguments[0]) {
+        const argument = typeReference.typeArguments[0];
+        if (typescript_1.default.isUnionTypeNode(argument)) {
+            if (mode) {
+                mode.supportAsync = true;
+                if (identifier === 'SupportAsyncManual') {
+                    mode.supportAsyncManual = true;
+                }
+            }
+            const types = argument.types.map(t => getParameterType(t, unionTypeCollector, mode));
+            const result = {
+                isArray: false,
+                value: types
+            };
+            if ((0, utils_1.isUnionType)(result)) {
+                unionTypeCollector.types.add(result.value);
+            }
+            return result;
+        }
+    }
+    return {
+        isArray: false,
+        value: getParameterBaseType(typeReference, mode)
+    };
+}
+function paramsNodeToArguments(parameter, unionTypeCollector) {
+    const args = new declaration_1.FunctionArguments();
+    args.name = getParameterName(parameter.name);
+    if (!parameter.type) {
+        console.warn(`Parameter ${args.name} has no type annotation, defaulting to any`);
+        args.type = { isArray: false, value: declaration_1.FunctionArgumentType.any };
+        return args;
+    }
+    const 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:
+            return processInterfaceDeclaration(statement, blob, definedPropertyCollector, unionTypeCollector);
+        case typescript_1.default.SyntaxKind.VariableStatement:
+            return processVariableStatement(statement, unionTypeCollector);
+        case typescript_1.default.SyntaxKind.TypeAliasDeclaration:
+            return processTypeAliasDeclaration(statement, blob);
+        default:
+            return null;
+    }
+}
+function processTypeAliasDeclaration(statement, blob) {
+    const typeAlias = new declaration_1.TypeAliasObject();
+    typeAlias.name = statement.name.text;
+    // Convert the type to a string representation
+    const printer = typescript_1.default.createPrinter();
+    typeAlias.type = printer.printNode(typescript_1.default.EmitHint.Unspecified, statement.type, statement.getSourceFile());
+    return typeAlias;
+}
+function processInterfaceDeclaration(statement, blob, definedPropertyCollector, unionTypeCollector) {
+    const interfaceName = statement.name.escapedText.toString();
+    const obj = new declaration_1.ClassObject();
+    // Process heritage clauses
+    if (statement.heritageClauses) {
+        const heritage = statement.heritageClauses[0];
+        const heritageType = getHeritageType(heritage);
+        const mixins = getMixins(heritage);
+        if (heritageType)
+            obj.parent = heritageType;
+        if (mixins)
+            obj.mixinParent = mixins;
+    }
+    obj.name = interfaceName;
+    if (obj.kind === declaration_1.ClassObjectKind.interface) {
+        definedPropertyCollector.interfaces.add('QJS' + interfaceName);
+        definedPropertyCollector.files.add(blob.filename);
+        definedPropertyCollector.properties.add(interfaceName);
+    }
+    // Process members in batches for better performance
+    const members = Array.from(statement.members);
+    processMembersBatch(members, obj, definedPropertyCollector, unionTypeCollector);
+    declaration_1.ClassObject.globalClassMap[interfaceName] = obj;
+    return obj;
+}
+function processMembersBatch(members, obj, definedPropertyCollector, unionTypeCollector) {
+    for (const member of members) {
+        try {
+            processMember(member, obj, definedPropertyCollector, unionTypeCollector);
+        }
+        catch (error) {
+            console.error(`Error processing member:`, error);
+        }
+    }
+}
+function processMember(member, obj, definedPropertyCollector, unionTypeCollector) {
+    switch (member.kind) {
+        case typescript_1.default.SyntaxKind.PropertySignature:
+            processPropertySignature(member, obj, definedPropertyCollector, unionTypeCollector);
+            break;
+        case typescript_1.default.SyntaxKind.MethodSignature:
+            processMethodSignature(member, obj, unionTypeCollector);
+            break;
+        case typescript_1.default.SyntaxKind.IndexSignature:
+            processIndexSignature(member, obj, unionTypeCollector);
+            break;
+        case typescript_1.default.SyntaxKind.ConstructSignature:
+            processConstructSignature(member, obj, unionTypeCollector);
+            break;
+    }
+}
+function processPropertySignature(member, obj, definedPropertyCollector, unionTypeCollector) {
+    const prop = new declaration_1.PropsDeclaration();
+    prop.name = getPropName(member.name, prop);
+    prop.readonly = isParamsReadOnly(member);
+    definedPropertyCollector.properties.add(prop.name);
+    if (!member.type) {
+        console.warn(`Property ${prop.name} has no type annotation`);
+        return;
+    }
+    const mode = new declaration_1.ParameterMode();
+    prop.type = getParameterType(member.type, unionTypeCollector, mode);
+    prop.typeMode = mode;
+    prop.optional = !!member.questionToken;
+    if (prop.type.value === declaration_1.FunctionArgumentType.function && typescript_1.default.isFunctionTypeNode(member.type)) {
+        const functionProps = prop;
+        functionProps.args = member.type.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));
+        obj.methods.push(functionProps);
+    }
+    else {
+        obj.props.push(prop);
+        // Handle async properties
+        if (prop.typeMode.supportAsync) {
+            const asyncProp = createAsyncProperty(prop, mode);
+            definedPropertyCollector.properties.add(asyncProp.name);
+            obj.props.push(asyncProp);
+        }
+    }
+}
+function createAsyncProperty(prop, mode) {
+    const asyncProp = Object.assign({}, prop);
+    const syncMode = Object.assign({}, mode);
+    syncMode.supportAsync = false;
+    syncMode.supportAsyncManual = false;
+    prop.typeMode = syncMode;
+    asyncProp.name = asyncProp.name + '_async';
+    asyncProp.async_type = {
+        isArray: false,
+        value: declaration_1.FunctionArgumentType.promise
+    };
+    return asyncProp;
+}
+function processMethodSignature(member, obj, unionTypeCollector) {
+    var _a;
+    const f = new declaration_1.FunctionDeclaration();
+    f.name = getPropName(member.name);
+    f.args = member.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));
+    if (member.type) {
+        const mode = new declaration_1.ParameterMode();
+        f.returnType = getParameterType(member.type, unionTypeCollector, mode);
+        if (mode.supportAsyncArrayValue) {
+            f.returnType = {
+                isArray: true,
+                value: f.returnType
+            };
+        }
+        f.returnTypeMode = mode;
+        if (f.returnTypeMode.staticMethod) {
+            obj.staticMethods.push(f);
+        }
+    }
+    obj.methods.push(f);
+    // Handle async methods
+    if ((_a = f.returnTypeMode) === null || _a === void 0 ? void 0 : _a.supportAsync) {
+        const asyncFunc = createAsyncMethod(member, f, unionTypeCollector);
+        obj.methods.push(asyncFunc);
+    }
+}
+function createAsyncMethod(member, originalFunc, unionTypeCollector) {
+    const asyncFunc = Object.assign({}, originalFunc);
+    const mode = Object.assign({}, originalFunc.returnTypeMode);
+    mode.supportAsync = false;
+    mode.supportAsyncManual = false;
+    originalFunc.returnTypeMode = mode;
+    asyncFunc.name = getPropName(member.name) + '_async';
+    asyncFunc.args = member.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));
+    asyncFunc.async_returnType = {
+        isArray: false,
+        value: declaration_1.FunctionArgumentType.promise
+    };
+    return asyncFunc;
+}
+function processIndexSignature(member, obj, unionTypeCollector) {
+    const prop = new declaration_1.IndexedPropertyDeclaration();
+    const modifier = member.modifiers;
+    prop.readonly = !!(modifier && modifier[0].kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
+    const params = member.parameters;
+    if (params.length > 0 && params[0].type) {
+        prop.indexKeyType = params[0].type.kind === typescript_1.default.SyntaxKind.NumberKeyword ? 'number' : 'string';
+    }
+    const mode = new declaration_1.ParameterMode();
+    prop.type = getParameterType(member.type, unionTypeCollector, mode);
+    prop.typeMode = mode;
+    obj.indexedProp = prop;
+}
+function processConstructSignature(member, obj, unionTypeCollector) {
+    const c = new declaration_1.FunctionDeclaration();
+    c.name = 'constructor';
+    c.args = member.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));
+    if (member.type) {
+        c.returnType = getParameterType(member.type, unionTypeCollector);
+    }
+    obj.construct = c;
+}
+function processVariableStatement(statement, unionTypeCollector) {
+    const declaration = statement.declarationList.declarations[0];
+    if (!typescript_1.default.isIdentifier(declaration.name)) {
+        console.warn('Variable declaration with non-identifier name is not supported');
+        return null;
+    }
+    const methodName = declaration.name.text;
+    const type = declaration.type;
+    if (!type || !typescript_1.default.isFunctionTypeNode(type)) {
+        return null;
+    }
+    const functionObject = new declaration_1.FunctionObject();
+    functionObject.declare = new declaration_1.FunctionDeclaration();
+    functionObject.declare.name = methodName;
+    functionObject.declare.args = type.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
+    functionObject.declare.returnType = getParameterType(type.type, unionTypeCollector);
+    return functionObject;
+}
+// Clear caches when needed (e.g., between runs)
+function clearCaches() {
+    sourceFileCache.clear();
+    typeConversionCache.clear();
+}