@openwebf/webf 0.22.3 → 0.22.5

package/dist/dart.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStringUnionType = isStringUnionType;
+exports.getUnionStringValues = getUnionStringValues;
+exports.generateDartClass = generateDartClass;
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const declaration_1 = require("./declaration");
+const utils_1 = require("./utils");
+function readTemplate(name) {
+    return fs_1.default.readFileSync(path_1.default.join(__dirname, '../templates/' + name + '.tpl'), { encoding: 'utf-8' });
+}
+// Generate enum name from property name
+function getEnumName(className, propName) {
+    // Remove 'Properties' or 'Bindings' suffix from className
+    const baseName = className.replace(/Properties$|Bindings$/, '');
+    // Convert to PascalCase
+    return baseName + lodash_1.default.upperFirst(lodash_1.default.camelCase(propName));
+}
+// Check if a type is a union of string literals
+function isStringUnionType(type) {
+    if (!Array.isArray(type.value))
+        return false;
+    // For now, we'll consider any union type as potentially a string union
+    // and let getUnionStringValues determine if it actually contains string literals
+    return type.value.length > 1;
+}
+// Extract string literal values from union type
+function getUnionStringValues(prop, blob) {
+    if (!isStringUnionType(prop.type))
+        return null;
+    // Try to get the actual string values from the source TypeScript file
+    const sourceContent = blob.raw;
+    if (!sourceContent)
+        return null;
+    // Look for the property definition in the source
+    // Need to escape special characters in property names (like value-color)
+    const escapedPropName = prop.name.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    const propPattern = new RegExp(`['"]?${escapedPropName}['"]?\\s*\\?\\s*:\\s*([^;]+);`);
+    const match = sourceContent.match(propPattern);
+    if (!match)
+        return null;
+    // Extract string literals from union type
+    const unionType = match[1];
+    const literalPattern = /'([^']+)'|"([^"]+)"/g;
+    const values = [];
+    let literalMatch;
+    while ((literalMatch = literalPattern.exec(unionType)) !== null) {
+        values.push(literalMatch[1] || literalMatch[2]);
+    }
+    return values.length > 0 ? values : null;
+}
+// Generate Dart enum from string values
+function generateDartEnum(enumName, values) {
+    const enumValues = values.map(value => {
+        // Convert kebab-case to camelCase for enum values
+        const enumValue = lodash_1.default.camelCase(value);
+        return `  ${enumValue}('${value}')`;
+    }).join(',\n');
+    return `enum ${enumName} {
+${enumValues};
+
+  final String value;
+  const ${enumName}(this.value);
+  
+  static ${enumName}? parse(String? value) {
+    if (value == null) return null;
+    return ${enumName}.values.firstWhere(
+      (e) => e.value == value,
+      orElse: () => throw ArgumentError('Invalid ${enumName} value: $value'),
+    );
+  }
+  
+  @override
+  String toString() => value;
+}`;
+}
+function generateReturnType(type, enumName) {
+    if ((0, utils_1.isPointerType)(type)) {
+        const pointerType = (0, utils_1.getPointerType)(type);
+        return pointerType;
+    }
+    if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
+        return `${(0, utils_1.getPointerType)(type.value)}[]`;
+    }
+    // Handle union types (e.g., 'left' | 'center' | 'right')
+    if (Array.isArray(type.value)) {
+        // If we have an enum name, use it; otherwise fall back to String
+        return enumName || 'String';
+    }
+    // Handle when type.value is a ParameterType object (nested type)
+    if (typeof type.value === 'object' && !Array.isArray(type.value) && type.value !== null) {
+        // This might be a nested ParameterType, recurse
+        return generateReturnType(type.value, enumName);
+    }
+    switch (type.value) {
+        case declaration_1.FunctionArgumentType.int: {
+            return 'int';
+        }
+        case declaration_1.FunctionArgumentType.double: {
+            return 'double';
+        }
+        case declaration_1.FunctionArgumentType.any: {
+            return 'any';
+        }
+        case declaration_1.FunctionArgumentType.boolean: {
+            return 'bool';
+        }
+        case declaration_1.FunctionArgumentType.dom_string: {
+            return 'String';
+        }
+        case declaration_1.FunctionArgumentType.void:
+            return 'void';
+        default:
+            return 'void';
+    }
+}
+function generateEventHandlerType(type) {
+    if (!(0, utils_1.isPointerType)(type)) {
+        throw new Error('Event type must be an instance of Event');
+    }
+    const pointerType = (0, utils_1.getPointerType)(type);
+    if (pointerType === 'Event') {
+        return `EventHandler`;
+    }
+    if (pointerType === 'CustomEvent') {
+        return `EventHandler<CustomEvent>`;
+    }
+    throw new Error('Unknown event type: ' + pointerType);
+}
+function generateAttributeSetter(propName, type, enumName) {
+    // Attributes from HTML are always strings, so we need to convert them
+    // Handle enum types
+    if (enumName && Array.isArray(type.value)) {
+        return `${propName} = ${enumName}.parse(value)`;
+    }
+    switch (type.value) {
+        case declaration_1.FunctionArgumentType.boolean:
+            return `${propName} = value == 'true' || value == ''`;
+        case declaration_1.FunctionArgumentType.int:
+            return `${propName} = int.tryParse(value) ?? 0`;
+        case declaration_1.FunctionArgumentType.double:
+            return `${propName} = double.tryParse(value) ?? 0.0`;
+        default:
+            // String and other types can be assigned directly
+            return `${propName} = value`;
+    }
+}
+function generateAttributeGetter(propName, type, optional, enumName) {
+    // Handle enum types
+    if (enumName && Array.isArray(type.value)) {
+        return optional ? `${propName}?.value` : `${propName}.value`;
+    }
+    // Handle nullable properties - they should return null if the value is null
+    if (optional && type.value !== declaration_1.FunctionArgumentType.boolean) {
+        // For nullable properties, we need to handle null values properly
+        return `${propName}?.toString()`;
+    }
+    // For non-nullable properties (including booleans), always convert to string
+    return `${propName}.toString()`;
+}
+function generateAttributeDeleter(propName, type, optional) {
+    // When deleting an attribute, we should reset it to its default value
+    switch (type.value) {
+        case declaration_1.FunctionArgumentType.boolean:
+            // Booleans default to false
+            return `${propName} = false`;
+        case declaration_1.FunctionArgumentType.int:
+            // Integers default to 0
+            return `${propName} = 0`;
+        case declaration_1.FunctionArgumentType.double:
+            // Doubles default to 0.0
+            return `${propName} = 0.0`;
+        case declaration_1.FunctionArgumentType.dom_string:
+            // Strings default to empty string or null for optional
+            if (optional) {
+                return `${propName} = null`;
+            }
+            return `${propName} = ''`;
+        default:
+            // For other types, set to null if optional, otherwise empty string
+            if (optional) {
+                return `${propName} = null`;
+            }
+            return `${propName} = ''`;
+    }
+}
+function generateMethodDeclaration(method) {
+    var methodName = method.name;
+    var args = method.args.map(arg => {
+        var argName = arg.name;
+        var argType = generateReturnType(arg.type);
+        return `${argName}: ${argType}`;
+    }).join(', ');
+    var returnType = generateReturnType(method.returnType);
+    return `${methodName}(${args}): ${returnType};`;
+}
+function shouldMakeNullable(prop) {
+    // Boolean properties should never be nullable in Dart, even if optional in TypeScript
+    if (prop.type.value === declaration_1.FunctionArgumentType.boolean) {
+        return false;
+    }
+    // Other optional properties remain nullable
+    return prop.optional;
+}
+function generateDartClass(blob, command) {
+    const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
+    const classObjectDictionary = Object.fromEntries(classObjects.map(object => {
+        return [object.name, object];
+    }));
+    const properties = classObjects.filter(object => {
+        return object.name.endsWith('Properties');
+    });
+    const events = classObjects.filter(object => {
+        return object.name.endsWith('Events');
+    });
+    const others = classObjects.filter(object => {
+        return !object.name.endsWith('Properties')
+            && !object.name.endsWith('Events');
+    });
+    const dependencies = others.map(object => {
+        const props = object.props.map(prop => {
+            if (prop.optional) {
+                return `${prop.name}?: ${generateReturnType(prop.type)};`;
+            }
+            return `${prop.name}: ${generateReturnType(prop.type)};`;
+        }).join('\n  ');
+        return `
+interface ${object.name} {
+  ${props}
+}`;
+    }).join('\n\n');
+    const componentProperties = properties.length > 0 ? properties[0] : undefined;
+    const componentEvents = events.length > 0 ? events[0] : undefined;
+    const className = (() => {
+        if (componentProperties) {
+            return componentProperties.name.replace(/Properties$/, '');
+        }
+        if (componentEvents) {
+            return componentEvents.name.replace(/Events$/, '');
+        }
+        return '';
+    })();
+    if (!className) {
+        return '';
+    }
+    // Generate enums for union types
+    const enums = [];
+    const enumMap = new Map(); // prop name -> enum name
+    if (componentProperties) {
+        for (const prop of componentProperties.props) {
+            if (isStringUnionType(prop.type)) {
+                const values = getUnionStringValues(prop, blob);
+                if (values && values.length > 0) {
+                    const enumName = getEnumName(componentProperties.name, prop.name);
+                    enums.push({
+                        name: enumName,
+                        definition: generateDartEnum(enumName, values)
+                    });
+                    enumMap.set(prop.name, enumName);
+                }
+            }
+        }
+    }
+    const content = lodash_1.default.template(readTemplate('class.dart'))({
+        className: className,
+        properties: componentProperties,
+        events: componentEvents,
+        classObjectDictionary,
+        dependencies,
+        blob,
+        generateReturnType: (type, propName) => {
+            // If we have a prop name, check if it has an enum
+            if (propName && enumMap.has(propName)) {
+                return enumMap.get(propName);
+            }
+            return generateReturnType(type);
+        },
+        generateMethodDeclaration,
+        generateEventHandlerType,
+        generateAttributeSetter: (propName, type) => {
+            return generateAttributeSetter(propName, type, enumMap.get(propName));
+        },
+        generateAttributeGetter: (propName, type, optional) => {
+            return generateAttributeGetter(propName, type, optional, enumMap.get(propName));
+        },
+        generateAttributeDeleter,
+        shouldMakeNullable,
+        command,
+        enums,
+        enumMap,
+    });
+    return content.split('\n').filter(str => {
+        return str.trim().length > 0;
+    }).join('\n');
+}

package/dist/declaration.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeAliasObject = exports.FunctionObject = exports.ClassObject = exports.ClassObjectKind = exports.FunctionDeclaration = exports.IndexedPropertyDeclaration = exports.PropsDeclaration = exports.ParameterMode = exports.FunctionArguments = exports.FunctionArgumentType = void 0;
+var FunctionArgumentType;
+(function (FunctionArgumentType) {
+    // Basic types
+    FunctionArgumentType[FunctionArgumentType["dom_string"] = 0] = "dom_string";
+    FunctionArgumentType[FunctionArgumentType["object"] = 1] = "object";
+    FunctionArgumentType[FunctionArgumentType["promise"] = 2] = "promise";
+    FunctionArgumentType[FunctionArgumentType["int"] = 3] = "int";
+    FunctionArgumentType[FunctionArgumentType["double"] = 4] = "double";
+    FunctionArgumentType[FunctionArgumentType["boolean"] = 5] = "boolean";
+    FunctionArgumentType[FunctionArgumentType["function"] = 6] = "function";
+    FunctionArgumentType[FunctionArgumentType["void"] = 7] = "void";
+    FunctionArgumentType[FunctionArgumentType["any"] = 8] = "any";
+    FunctionArgumentType[FunctionArgumentType["null"] = 9] = "null";
+    FunctionArgumentType[FunctionArgumentType["undefined"] = 10] = "undefined";
+    FunctionArgumentType[FunctionArgumentType["array"] = 11] = "array";
+    FunctionArgumentType[FunctionArgumentType["js_array_proto_methods"] = 12] = "js_array_proto_methods";
+})(FunctionArgumentType || (exports.FunctionArgumentType = FunctionArgumentType = {}));
+class FunctionArguments {
+}
+exports.FunctionArguments = FunctionArguments;
+class ParameterMode {
+}
+exports.ParameterMode = ParameterMode;
+class PropsDeclaration {
+}
+exports.PropsDeclaration = PropsDeclaration;
+class IndexedPropertyDeclaration extends PropsDeclaration {
+}
+exports.IndexedPropertyDeclaration = IndexedPropertyDeclaration;
+class FunctionDeclaration extends PropsDeclaration {
+    constructor() {
+        super(...arguments);
+        this.args = [];
+    }
+}
+exports.FunctionDeclaration = FunctionDeclaration;
+var ClassObjectKind;
+(function (ClassObjectKind) {
+    ClassObjectKind[ClassObjectKind["interface"] = 0] = "interface";
+    ClassObjectKind[ClassObjectKind["dictionary"] = 1] = "dictionary";
+    ClassObjectKind[ClassObjectKind["mixin"] = 2] = "mixin";
+})(ClassObjectKind || (exports.ClassObjectKind = ClassObjectKind = {}));
+class ClassObject {
+    constructor() {
+        this.props = [];
+        this.inheritedProps = [];
+        this.methods = [];
+        this.staticMethods = [];
+        this.kind = ClassObjectKind.interface;
+    }
+}
+exports.ClassObject = ClassObject;
+ClassObject.globalClassMap = Object.create(null);
+ClassObject.globalClassRelationMap = Object.create(null);
+class FunctionObject {
+}
+exports.FunctionObject = FunctionObject;
+class TypeAliasObject {
+}
+exports.TypeAliasObject = TypeAliasObject;