npm - @idlizer/core - Versions diffs - 2.0.41 → 2.1.0 - Mend

@idlizer/core 2.0.41 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

package/build/lib/src/config.js CHANGED Viewed

@@ -12,7 +12,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export const defaultCoreConfuguration = {
+import { D } from "./configDescriber";
+const T = {
+    stringArray: () => D.array(D.string())
+};
+export const CoreConfigurationSchema = D.object({
+    TypePrefix: D.string(),
+    LibraryPrefix: D.string(),
+    OptionalPrefix: D.string(),
+    rootComponents: T.stringArray(),
+    standaloneComponents: T.stringArray(),
+    parameterized: T.stringArray(),
+    ignoreMaterialized: T.stringArray(),
+    builderClasses: T.stringArray(),
+    forceMaterialized: T.stringArray(),
+    forceCallback: T.stringArray(),
+    forceContext: T.stringArray(),
+});
+export const defaultCoreConfiguration = {
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
@@ -22,11 +39,16 @@ export const defaultCoreConfuguration = {
     ignoreMaterialized: [],
     builderClasses: [],
     forceMaterialized: [],
+    forceCallback: [],
+    forceContext: [],
 };
-let currentConfig = defaultCoreConfuguration;
+let currentConfig = defaultCoreConfiguration;
 export function setDefaultConfiguration(config) {
     currentConfig = config;
 }
+export function patchDefaultConfiguration(config) {
+    currentConfig = Object.assign({}, currentConfig, config);
+}
 export function generatorConfiguration() {
     return currentConfig;
 }

package/build/lib/src/configDescriber.d.ts ADDED Viewed

@@ -0,0 +1,85 @@
+export interface JsonSchemaLeaf {
+    type?: string;
+    description?: string;
+}
+export interface JsonSchemaArray extends JsonSchemaLeaf {
+    items: JsonSchemaNode;
+}
+export interface JsonSchemaTuple extends JsonSchemaLeaf {
+    items: JsonSchemaNode[];
+}
+export interface JsonSchemaMap extends JsonSchemaLeaf {
+    additionalProperties: JsonSchemaNode;
+}
+export interface JsonSchemaObject extends JsonSchemaLeaf {
+    properties: Record<string, JsonSchemaNode>;
+    required: string[];
+    additionalProperties: boolean;
+}
+export type JsonSchemaNode = JsonSchemaLeaf | JsonSchemaArray | JsonSchemaTuple | JsonSchemaMap | JsonSchemaObject;
+export interface JsonSchema {
+    $ref: string;
+    $schema: string;
+    definitions: Record<string, JsonSchemaNode>;
+}
+type UnwrapConfigDescriberLeaf<T> = T extends ConfigDescriberLeaf<infer K> ? K : never;
+type ObjectDescriptionToType<T extends {}> = {
+    readonly [x in keyof T]: UnwrapConfigDescriberLeaf<T[x]>;
+};
+type TraverseTuple<Ts extends any[]> = Ts extends [] ? [] : Ts extends [infer Head, ...infer Rest] ? [UnwrapConfigDescriberLeaf<Head>, ...TraverseTuple<Rest>] : never;
+export interface ValidationSuccess<T> {
+    success: true;
+    value: T;
+}
+export interface ValidationFailure {
+    success: false;
+    errorMessage: string;
+}
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
+declare class ValidationBox<T> {
+    box: ValidationResult<T>;
+    constructor(box: ValidationResult<T>);
+    static fail<T>(errorMessage: string): ValidationBox<T>;
+    static ok<T>(value: T): ValidationBox<T>;
+    success(): boolean;
+    unwrap(): T;
+    error(): string;
+    get(): ValidationResult<T>;
+    or<U>(x: U): ValidationBox<U | T>;
+}
+declare class ConfigDescriberLeaf<T> {
+    validate: (x: unknown) => ValidationBox<T>;
+    printSchema: () => JsonSchemaNode;
+    constructor(validate: (x: unknown) => ValidationBox<T>, printSchema: () => JsonSchemaNode);
+}
+declare class ConfigDescriberOptionalLeaf<T> extends ConfigDescriberLeaf<T> {
+    constructor(validate: (x: unknown) => ValidationBox<T>, printSchema: () => JsonSchemaNode);
+}
+declare class ConfigDescriberObjectLeaf<T> extends ConfigDescriberLeaf<T> {
+    schema: Record<string, ConfigDescriberLeaf<T>>;
+    constructor(validate: (x: unknown) => ValidationBox<T>, printSchema: () => JsonSchemaNode, schema: Record<string, ConfigDescriberLeaf<T>>);
+}
+export type ConfigSchema<T> = ConfigDescriberLeaf<T>;
+export interface CommonBuilderConfig<T> {
+    default?: T;
+    description?: string;
+}
+export declare const D: {
+    number(config?: CommonBuilderConfig<number>): ConfigDescriberLeaf<number>;
+    string(config?: CommonBuilderConfig<string>): ConfigDescriberLeaf<string>;
+    boolean(config?: CommonBuilderConfig<boolean>): ConfigDescriberLeaf<boolean>;
+    bigint(config?: CommonBuilderConfig<bigint>): ConfigDescriberLeaf<bigint>;
+    null(config?: CommonBuilderConfig<null>): ConfigDescriberLeaf<null>;
+    undefined(config?: CommonBuilderConfig<undefined>): ConfigDescriberLeaf<undefined>;
+    object<K extends Record<string, ConfigDescriberLeaf<any>>>(schema: K): ConfigDescriberObjectLeaf<ObjectDescriptionToType<K>>;
+    maybe<T>(type: ConfigDescriberLeaf<T>): ConfigDescriberOptionalLeaf<T | undefined>;
+    default<T_1>(type: ConfigDescriberLeaf<T_1>, def: T_1): ConfigDescriberOptionalLeaf<T_1>;
+    array<T_2>(type: ConfigDescriberLeaf<T_2>, initAsEmpty?: boolean): ConfigDescriberLeaf<T_2[]>;
+    map<K_1, V>(keySchema: ConfigDescriberLeaf<K_1>, valSchema: ConfigDescriberLeaf<V>): ConfigDescriberLeaf<Map<K_1, V>>;
+    tuple<Ts extends ConfigDescriberLeaf<any>[]>(...items: Ts): ConfigDescriberLeaf<TraverseTuple<Ts>>;
+    combine<A, B>(a: ConfigDescriberObjectLeaf<A>, b: ConfigDescriberObjectLeaf<B>): ConfigDescriberObjectLeaf<A & B>;
+    printJSONSchema<T_3>(schema: ConfigDescriberLeaf<T_3>): string;
+};
+export type ConfigTypeInfer<T> = UnwrapConfigDescriberLeaf<T>;
+export {};
+//# sourceMappingURL=configDescriber.d.ts.map

package/build/lib/src/configDescriber.js ADDED Viewed

@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { zip } from "./util";
+class ValidationBox {
+    constructor(box) {
+        this.box = box;
+    }
+    static fail(errorMessage) {
+        return new ValidationBox({ success: false, errorMessage });
+    }
+    static ok(value) {
+        return new ValidationBox({ success: true, value });
+    }
+    success() {
+        return this.box.success;
+    }
+    unwrap() {
+        if (this.box.success) {
+            return this.box.value;
+        }
+        throw new Error("");
+    }
+    error() {
+        if (!this.box.success) {
+            return this.box.errorMessage;
+        }
+        throw new Error("");
+    }
+    get() {
+        return this.box;
+    }
+    or(x) {
+        if (this.box.success) {
+            return new ValidationBox(this.box);
+        }
+        return new ValidationBox({
+            success: true,
+            value: x
+        });
+    }
+}
+class ConfigDescriberLeaf {
+    constructor(validate, printSchema) {
+        this.validate = validate;
+        this.printSchema = printSchema;
+    }
+}
+class ConfigDescriberOptionalLeaf extends ConfigDescriberLeaf {
+    constructor(validate, printSchema) { super(validate, printSchema); }
+}
+class ConfigDescriberObjectLeaf extends ConfigDescriberLeaf {
+    constructor(validate, printSchema, schema) {
+        super(validate, printSchema);
+        this.schema = schema;
+    }
+}
+function mk(typeName, check, config) {
+    return new ConfigDescriberLeaf(x => {
+        if (check(x)) {
+            return new ValidationBox({
+                success: true,
+                value: x
+            });
+        }
+        if (config !== undefined && 'default' in config) {
+            return new ValidationBox({
+                success: true,
+                value: config.default
+            });
+        }
+        return new ValidationBox({
+            success: false,
+            errorMessage: `Expected "${typeName}"`
+        });
+    }, () => {
+        const base = {
+            type: typeName,
+        };
+        if (config === null || config === void 0 ? void 0 : config.description) {
+            base.description = config === null || config === void 0 ? void 0 : config.description;
+        }
+        return base;
+    });
+}
+export const D = {
+    ////////////////////////////////////////
+    // Basics
+    number(config) {
+        return mk('number', x => typeof x === 'number', config);
+    },
+    string(config) {
+        return mk('string', x => typeof x === 'string', config);
+    },
+    boolean(config) {
+        return mk('boolean', x => typeof x === 'boolean', config);
+    },
+    bigint(config) {
+        return mk('bigint', x => typeof x === 'bigint', config);
+    },
+    null(config) {
+        return mk('null', x => x === null, config);
+    },
+    undefined(config) {
+        return mk('undefined', x => x === undefined, config);
+    },
+    object(schema) {
+        return new ConfigDescriberObjectLeaf(x => {
+            if (x !== undefined) {
+                if (typeof x !== 'object') {
+                    return ValidationBox.fail(`Expected object, but got "${typeof x}"`);
+                }
+                if (x === null) {
+                    return ValidationBox.fail(`Expected object, but got "null"`);
+                }
+            }
+            const obj = x;
+            const sh = schema;
+            const result = {};
+            const errors = [];
+            for (const key in schema) {
+                const box = sh[key].validate(obj === undefined ? undefined : obj[key]);
+                if (box.success()) {
+                    const val = box.unwrap();
+                    if (val === undefined && obj !== undefined && !(key in obj)) {
+                        continue;
+                    }
+                    result[key] = val;
+                }
+                else {
+                    errors.push(`"${key}":\n${box.error().split('\n').map(s => '\t' + s).join('\n')}`);
+                }
+            }
+            if (errors.length) {
+                return ValidationBox.fail(errors.join('\n'));
+            }
+            return new ValidationBox({
+                success: true,
+                value: result
+            });
+        }, () => {
+            const properties = {};
+            const required = [];
+            for (const key in schema) {
+                const leaf = schema[key];
+                properties[key] = leaf.printSchema();
+                if (!(leaf instanceof ConfigDescriberOptionalLeaf)) {
+                    required.push(key);
+                }
+            }
+            return {
+                additionalProperties: false,
+                properties,
+                required,
+                type: "object"
+            };
+        }, schema);
+    },
+    ////////////////////////////////////////
+    // Advanced
+    maybe(type) {
+        return new ConfigDescriberOptionalLeaf(x => {
+            if (x === undefined) {
+                return ValidationBox.ok(undefined);
+            }
+            return type.validate(x);
+        }, () => {
+            return type.printSchema();
+        });
+    },
+    default(type, def) {
+        return new ConfigDescriberOptionalLeaf(x => {
+            return type.validate(x).or(def);
+        }, () => {
+            return type.printSchema();
+        });
+    },
+    array(type, initAsEmpty = true) {
+        return new ConfigDescriberLeaf(xs => {
+            if ((xs === undefined || xs === null) && initAsEmpty) {
+                return ValidationBox.ok([]);
+            }
+            if (!Array.isArray(xs)) {
+                return ValidationBox.fail("Expected array");
+            }
+            const result = [];
+            for (const x of xs) {
+                const box = type.validate(x);
+                if (!box.success()) {
+                    return ValidationBox.fail("Array item: " + box.error());
+                }
+                result.push(box.unwrap());
+            }
+            return ValidationBox.ok(result);
+        }, () => {
+            return {
+                type: 'array',
+                items: type.printSchema()
+            };
+        });
+    },
+    map(keySchema, valSchema) {
+        return new ConfigDescriberLeaf(x => {
+            if (x === undefined) {
+                return ValidationBox.fail(`Expected Map, but got "undefined"`);
+            }
+            if (typeof x !== 'object' || x === null) {
+                return ValidationBox.fail(`Expected Map, but got "${x === null ? 'null' : typeof x}"`);
+            }
+            const result = new Map();
+            const iterable = x instanceof Map ? x : Object.entries(x);
+            for (const [key, val] of iterable) {
+                const keyResult = keySchema.validate(key);
+                if (!keyResult.success()) {
+                    return ValidationBox.fail("Map key: " + keyResult.error());
+                }
+                const valResult = valSchema.validate(val);
+                if (!valResult.success()) {
+                    return ValidationBox.fail("Map value: " + valResult.error());
+                }
+                result.set(keyResult.unwrap(), valResult.unwrap());
+            }
+            return ValidationBox.ok(result);
+        }, () => {
+            return {
+                type: 'object',
+                additionalProperties: valSchema.printSchema()
+            };
+        });
+    },
+    tuple(...items) {
+        return new ConfigDescriberLeaf(xs => {
+            if (!Array.isArray(xs)) {
+                return ValidationBox.fail('Expected tuple');
+            }
+            if (xs.length !== items.length) {
+                return ValidationBox.fail(`Expected tuple of size ${items.length}, but size was ${xs.length}`);
+            }
+            const result = [];
+            zip(xs, items).forEach(([val, leaf], i) => {
+                const r = leaf.validate(val);
+                if (!r.success()) {
+                    return ValidationBox.fail(`Tuple position ${i}: ${r.error()}`);
+                }
+                result.push(r.unwrap());
+            });
+            return ValidationBox.ok(result);
+        }, () => {
+            return {
+                items: items.map(it => it.printSchema())
+            };
+        });
+    },
+    ////////////////////////////////////////
+    // Utils
+    combine(a, b) {
+        const keysA = new Set(Object.keys(a.schema));
+        const keysB = Object.keys(b.schema);
+        for (const key of keysB) {
+            if (keysA.has(key)) {
+                throw new Error(`Can not combine objects with same keys. Key: "${key}"`);
+            }
+        }
+        return D.object(Object.assign(Object.assign({}, a.schema), b.schema));
+    },
+    ////////////////////////////////////////
+    // Helpers
+    printJSONSchema(schema) {
+        const configSchema = schema.printSchema();
+        if ("properties" in configSchema) {
+            configSchema.properties.$schema = {
+                type: "string",
+                description: "The schema to verify this document against."
+            };
+        }
+        const json = {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            $ref: "#/definitions/configSchema",
+            definitions: {
+                configSchema
+            }
+        };
+        return JSON.stringify(json, null, 4);
+    }
+};
+//# sourceMappingURL=configDescriber.js.map

package/build/lib/src/from-idl/DtsPrinter.js CHANGED Viewed

@@ -13,10 +13,11 @@
  * limitations under the License.
  */
 import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType } from "../idl";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate } from "../idl";
 import { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
+import { isInIdlize } from "../idlize";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -31,7 +32,7 @@ export class CustomPrintVisitor {
             this.print(`${!isTopmost ? "" : "declare "}namespace ${namespace.name} {`);
             this.pushIndent();
         }
-        if (hasExtAttribute(node, IDLExtendedAttributes.TSType) && this.language == Language.TS)
+        if (isInIdlize(node))
             return;
         if (isInterface(node)) {
             this.printInterface(node);
@@ -288,6 +289,7 @@ export class CustomPrintVisitor {
                 case IDLThisType: return "T";
                 case IDLBigintType:
                 case IDLPointerType: return "number|bigint";
+                case IDLDate: return "Date";
                 default: throw new Error(`Unknown primitive type ${DebugUtils.debugPrintType(type)}`);
             }
         }

package/build/lib/src/from-idl/IDLLinter.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import * as idl from "../idl";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export interface IDLLinterOptions {
+    validEntryAttributes: Map<idl.IDLKind, string[]>;
+    checkEnumsConsistency: boolean;
+    checkReferencesResolved: boolean;
+}
+export declare class IDLLinter {
+    protected node: idl.IDLNode;
+    protected resolver: ReferenceResolver;
+    protected options: IDLLinterOptions;
+    constructor(node: idl.IDLNode, resolver: ReferenceResolver, options: IDLLinterOptions);
+    private entryErrors;
+    private pushError;
+    result: string;
+    visit(): string;
+    protected check(node: idl.IDLNode): void;
+    protected checkValidAttributes(entry: idl.IDLEntry, validAttributes: string[]): void;
+    protected checkEnumConsistency(entry: idl.IDLEnum): void;
+    private static builtinReferences;
+    protected checkReferenceResolved(reference: idl.IDLReferenceType): void;
+}
+export declare function verifyIDLLinter(node: idl.IDLNode, resolver: ReferenceResolver, options: IDLLinterOptions): true;
+//# sourceMappingURL=IDLLinter.d.ts.map

package/build/lib/src/from-idl/IDLLinter.js ADDED Viewed

@@ -0,0 +1,81 @@
+import * as idl from "../idl";
+export class IDLLinter {
+    constructor(node, resolver, options) {
+        this.node = node;
+        this.resolver = resolver;
+        this.options = options;
+        this.result = "";
+    }
+    pushError(node, error) {
+        const name = typeof node === 'string' ? node : idl.getFQName(node);
+        if (!this.entryErrors)
+            this.entryErrors = {};
+        if (!this.entryErrors[name])
+            this.entryErrors[name] = [];
+        this.entryErrors[name].push(error);
+    }
+    visit() {
+        this.check(this.node);
+        idl.forEachChild(this.node, node => {
+            this.check(node);
+        });
+        this.result = !this.entryErrors ? "" : JSON.stringify(this.entryErrors, undefined, 2);
+        return this.result;
+    }
+    check(node) {
+        var _a;
+        if (idl.isEntry(node)) {
+            this.checkValidAttributes(node, (_a = this.options.validEntryAttributes.get(node.kind)) !== null && _a !== void 0 ? _a : []);
+        }
+        if (this.options.checkEnumsConsistency && idl.isEnum(node)) {
+            this.checkEnumConsistency(node);
+        }
+        if (this.options.checkReferencesResolved && idl.isReferenceType(node)) {
+            this.checkReferenceResolved(node);
+        }
+    }
+    checkValidAttributes(entry, validAttributes) {
+        if (!entry.extendedAttributes)
+            return;
+        for (const attr of entry.extendedAttributes) {
+            if (!validAttributes.includes(attr.name))
+                this.pushError(entry, `${entry.kind}: Invalid attribute '${attr.name}'`);
+        }
+    }
+    checkEnumConsistency(entry) {
+        let hasNumber = false;
+        let hasString = false;
+        for (const element of entry.elements) {
+            if (typeof element.initializer === 'string')
+                hasString = true;
+            if (typeof element.initializer === 'number')
+                hasNumber = true;
+        }
+        if (hasNumber && hasString)
+            this.pushError(entry, "Enum includes both string and number values");
+    }
+    checkReferenceResolved(reference) {
+        if (IDLLinter.builtinReferences.includes(reference.name))
+            return;
+        const resolved = this.resolver.resolveTypeReference(reference);
+        if (resolved === undefined) {
+            const parentFile = idl.getFileFor(reference);
+            const parentNamespace = idl.fetchNamespaceFrom(reference);
+            const scopeName = parentNamespace ? idl.getFQName(parentNamespace) : idl.getPackageName(parentFile);
+            this.pushError(scopeName, `Can not resolve reference '${reference.name}' defined in scope '${scopeName}' in file '${parentFile.fileName}''`);
+        }
+    }
+}
+IDLLinter.builtinReferences = [
+    idl.IDLTopType.name,
+    idl.IDLObjectType.name,
+];
+class IDLLinterError extends Error {
+}
+export function verifyIDLLinter(node, resolver, options) {
+    const result = new IDLLinter(node, resolver, options).visit();
+    if (result.length)
+        throw new IDLLinterError(result);
+    return true;
+}
+//# sourceMappingURL=IDLLinter.js.map

package/build/lib/src/from-idl/deserialize.js CHANGED Viewed

@@ -14,7 +14,7 @@
  */
 import * as webidl2 from "webidl2";
 import * as fs from "fs";
-import { isAttribute, isCallback, isClass, isConstructor, isDictionary, isEnum, isInterface, isOperation, isOptional, isPromiseTypeDescription, isRecordTypeDescription, isSequenceTypeDescription, isSingleTypeDescription, isTypedef, isUnionTypeDescription, isUnspecifiedGenericTypeDescription } from "./webidl2-utils";
+import { isAttribute, isCallback, isClass, isConstant, isConstructor, isDictionary, isEnum, isInterface, isOperation, isOptional, isPromiseTypeDescription, isRecordTypeDescription, isSequenceTypeDescription, isSingleTypeDescription, isTypedef, isUnionTypeDescription, isUnspecifiedGenericTypeDescription } from "./webidl2-utils";
 import { toString } from "./toString";
 import * as idl from "../idl";
 import { isDefined, warn } from "../util";
@@ -65,6 +65,9 @@ function toIDLNodeForward(file, node) {
     if (isOperation(node)) {
         return toIDLMethod(file, node);
     }
+    if (isConstant(node)) {
+        return toIDLConstant(file, node);
+    }
     throw new Error(`unexpected node type: ${toString(node)}`);
 }
 function isNamespace(node) {
@@ -86,9 +89,20 @@ function toIDLImport(node) {
     // console.log(node)
     return idl.createImport(node.clause.split("."), node.alias || undefined);
 }
+function interfaceSubkind(node) {
+    var _a, _b;
+    const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
+    if (nodeIDLEntity == idl.IDLEntity.Class)
+        return idl.IDLInterfaceSubkind.Class;
+    if (nodeIDLEntity == idl.IDLEntity.Interface)
+        return idl.IDLInterfaceSubkind.Interface;
+    if (nodeIDLEntity == idl.IDLEntity.Tuple)
+        return idl.IDLInterfaceSubkind.Tuple;
+    return idl.IDLInterfaceSubkind.Interface;
+}
 function toIDLInterface(file, node) {
     var _a;
-    const result = idl.createInterface(node.name, isClass(node) ? idl.IDLInterfaceSubkind.Class : idl.IDLInterfaceSubkind.Interface, (() => {
+    const result = idl.createInterface(node.name, interfaceSubkind(node), (() => {
         var _a, _b;
         if (!node.inheritance)
             return [];
@@ -113,8 +127,6 @@ function toIDLInterface(file, node) {
         documentation: makeDocs(node),
         extendedAttributes: toExtendedAttributes(node.extAttrs),
     });
-    if (result.inheritance.length && idl.isReferenceType(result.inheritance[0]))
-        result.inheritance[0].typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
     if (node.extAttrs.find(it => it.name === "Synthetic"))
         addSyntheticType(node.name, result);
     return result;
@@ -249,6 +261,31 @@ function toIDLTypedef(file, node) {
         fileName: file,
     });
 }
+function toIDLConstant(file, node) {
+    return idl.createConstant(node.name, toIDLType(file, node.idlType), constantValue(node));
+}
+function constantValue(node) {
+    switch (node.value.type) {
+        case "string":
+            return `"${node.value.value}"`;
+        case "number":
+            return node.value.value;
+        case "boolean":
+            return node.value.value.toString();
+        case "null":
+            return "null";
+        case "Infinity":
+            return "Infinity";
+        case "NaN":
+            return "NaN";
+        case "sequence":
+            return `[${node.value.value.join(',')}]`;
+        case "dictionary":
+            return `new Map()`;
+        default:
+            return "undefined";
+    }
+}
 function toIDLDictionary(file, node) {
     const result = idl.createEnum(node.name, [], {
         documentation: makeDocs(node),

package/build/lib/src/from-idl/webidl2-utils.d.ts CHANGED Viewed

@@ -15,6 +15,7 @@ export declare function isSingleTypeDescription(node: webidl2.IDLTypeDescription
 export declare function isSequenceTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SequenceTypeDescription;
 export declare function isPromiseTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.PromiseTypeDescription;
 export declare function isRecordTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.RecordTypeDescription;
+export declare function isConstant(node: webidl2.IDLRootType): node is webidl2.ConstantMemberType;
 export declare function isUnspecifiedGenericTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnspecifiedGenericTypeDescription;
 export declare function isOptional(node: webidl2.AttributeMemberType | webidl2.OperationMemberType): boolean;
 //# sourceMappingURL=webidl2-utils.d.ts.map

package/build/lib/src/from-idl/webidl2-utils.js CHANGED Viewed

@@ -63,6 +63,9 @@ export function isPromiseTypeDescription(node) {
 export function isRecordTypeDescription(node) {
     return node.generic === "record";
 }
+export function isConstant(node) {
+    return node.type === "const";
+}
 export function isUnspecifiedGenericTypeDescription(node) {
     switch (node.generic) {
         case "FrozenArray":