@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-7

package/build/lib/src/idl/discriminators.js

@@ -0,0 +1,232 @@
+/*
+ * 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 { isDefined } from "../util";
+import { IDLKind, IDLInterfaceSubkind, IDLExtendedAttributes } from "./node";
+/////////////////////////////////////////////////////////////////
+// BASICS
+export function isFile(node) {
+    return node.kind === IDLKind.File;
+}
+export function isPrimitiveType(type) {
+    return type.kind == IDLKind.PrimitiveType;
+}
+export function isContainerType(type) {
+    return type.kind == IDLKind.ContainerType;
+}
+export function isReferenceType(type) {
+    return type.kind == IDLKind.ReferenceType;
+}
+export function isEnum(type) {
+    return type.kind == IDLKind.Enum;
+}
+export function isEnumMember(type) {
+    return type.kind == IDLKind.EnumMember;
+}
+export function isUnionType(type) {
+    return type.kind == IDLKind.UnionType;
+}
+export function isTypeParameterType(type) {
+    return type.kind == IDLKind.TypeParameterType;
+}
+export function isInterface(node) {
+    return node.kind === IDLKind.Interface;
+}
+export function isImport(type) {
+    return type.kind == IDLKind.Import;
+}
+export function isCallable(node) {
+    return node.kind === IDLKind.Callable;
+}
+export function isMethod(node) {
+    return node.kind === IDLKind.Method;
+}
+export function isParameter(node) {
+    return node.kind === IDLKind.Parameter;
+}
+export function isConstructor(node) {
+    return node.kind === IDLKind.Constructor;
+}
+export function isProperty(node) {
+    return node.kind === IDLKind.Property;
+}
+export function isCallback(node) {
+    return node.kind === IDLKind.Callback;
+}
+export function isInterfaceSubkind(idl) {
+    return idl.subkind === IDLInterfaceSubkind.Interface;
+}
+export function isClassSubkind(idl) {
+    return idl.subkind === IDLInterfaceSubkind.Class;
+}
+export function isConstant(node) {
+    return node.kind === IDLKind.Const;
+}
+export function isTypedef(node) {
+    return node.kind === IDLKind.Typedef;
+}
+export function isType(node) {
+    return "_idlTypeBrand" in node;
+}
+export function isEntry(node) {
+    return "_idlEntryBrand" in node;
+}
+export function isNamespace(node) {
+    return node.kind === IDLKind.Namespace;
+}
+export function isSyntheticEntry(node) {
+    var _a;
+    return isDefined((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === IDLExtendedAttributes.Synthetic));
+}
+export function isOptionalType(type) {
+    return type.kind === IDLKind.OptionalType;
+}
+export function isVersion(node) {
+    return node.kind === IDLKind.Version;
+}
+export function isNamedNode(type) {
+    return "_idlNamedNodeBrand" in type;
+}
+export const IDLContainerUtils = {
+    isRecord: (x) => isContainerType(x) && x.containerKind === 'record',
+    isSequence: (x) => isContainerType(x) && x.containerKind === 'sequence',
+    isPromise: (x) => isContainerType(x) && x.containerKind === 'Promise'
+};
+/////////////////////////////////////////////////////////////////
+// EXTENDED ATTRIBUTES
+export function hasExtAttribute(node, attribute) {
+    var _a;
+    return ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find((it) => it.name == attribute)) != undefined;
+}
+export function getExtAttribute(node, name) {
+    var _a, _b;
+    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.value;
+}
+export function removeExtAttribute(node, name) {
+    if (node.extendedAttributes) {
+        node.extendedAttributes = node.extendedAttributes.filter(it => it.name !== name);
+    }
+}
+export function getExtAttributeTypesValue(node, name) {
+    var _a, _b;
+    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.typesValue;
+}
+export function updateExtAttribute(node, name, value) {
+    var _a;
+    removeExtAttribute(node, name);
+    (_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : (node.extendedAttributes = []);
+    node.extendedAttributes.push({ name, value });
+}
+/////////////////////////////////////////////////////////////////
+// ADVANCED
+export function getNamespacesPathFor(node) {
+    let iterator = node.parent;
+    const result = [];
+    while (iterator) {
+        if (isNamespace(iterator))
+            result.unshift(iterator);
+        iterator = iterator.parent;
+    }
+    return result;
+}
+const nodesWithoutIDLFiles = new Set();
+export function getFileFor(node) {
+    let iterator = node;
+    while (iterator) {
+        if (isFile(iterator))
+            return iterator;
+        iterator = iterator.parent;
+    }
+    const name = getQualifiedName(node, "namespace.name");
+    if (!nodesWithoutIDLFiles.has(name)) {
+        console.warn(`Node ${name} does not have IDLFile in parents`);
+        nodesWithoutIDLFiles.add(name);
+    }
+    return undefined;
+}
+export function getPackageClause(node) {
+    var _a;
+    const file = getFileFor(node);
+    if (!file)
+        throw new Error(`Can not find parent file for node ${node.kind}`);
+    return (_a = file === null || file === void 0 ? void 0 : file.packageClause) !== null && _a !== void 0 ? _a : [];
+}
+export function getPackageName(node) {
+    return getPackageClause(node).join(".");
+}
+export function getPackageNameSafe(node) {
+    try {
+        return getPackageName(node);
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+export function isInPackage(entry, packageName, exactMatch = false) {
+    const entryPackageName = getPackageName(entry);
+    return exactMatch
+        ? entryPackageName === packageName
+        : entryPackageName.startsWith(packageName);
+}
+export function getNamespaceName(a) {
+    return getNamespacesPathFor(a).map(it => it.name).join('.');
+}
+export function deriveQualifiedNameFrom(name, from) {
+    return [...getPackageClause(from), ...getNamespacesPathFor(from).map(it => it.name), name].join(".");
+}
+export function getQualifiedName(a, pattern) {
+    const result = [];
+    if ("package.namespace.name" === pattern)
+        result.push(...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name));
+    else if ("namespace.name" === pattern)
+        result.push(...getNamespacesPathFor(a).map(it => it.name));
+    const ownName = (node) => {
+        if (!node || isFile(node))
+            return [];
+        if (isNamespace(node))
+            return node === a ? [node.name] : [];
+        if (isInterface(node) || isTypedef(node) || isCallback(node) || isEnum(node))
+            return [node.name];
+        if (isProperty(node) || isMethod(node) || isConstant(node))
+            return [...ownName(node.parent), node.name];
+        if (isCallable(node))
+            return [...ownName(node.parent), "invoke"];
+        if (isConstructor(node))
+            return [...ownName(node.parent), "constructor"];
+        throw new Error(`Can not calculate own name for node ${node.kind}`);
+    };
+    result.push(...ownName(a));
+    return result.join(".");
+}
+export function getFQName(a) {
+    return getQualifiedName(a, "package.namespace.name");
+}
+export function getFQNameSafe(a) {
+    try {
+        return getFQName(a);
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+export function fetchNamespaceFrom(pointOfView) {
+    let node = pointOfView;
+    while (node) {
+        if (isNamespace(node))
+            return node;
+        node = node.parent;
+    }
+    return undefined;
+}
+//# sourceMappingURL=discriminators.js.map

package/build/lib/src/idl/dump.d.ts

@@ -0,0 +1,48 @@
+import { IndentedPrinter } from "../IndentedPrinter";
+import { stringOrNone } from "../util";
+import { IDLType, IDLInterface, IDLParameter, IDLConstructor, IDLVariable, IDLConstant, IDLProperty, IDLNode, IDLTypedef, IDLExtendedAttribute, IDLFunction, IDLMethod, IDLFile, IDLImport, IDLNamespace, IDLCallback, IDLEntry, IDLEnumMember, IDLEnum } from "./node";
+export declare function escapeIDLKeyword(name: string): string;
+export declare function unescapeKeyword(name: string): string;
+type PrintTypeOptions = {
+    [key: string]: any;
+};
+export declare function printType(type: IDLType | IDLInterface | undefined, options?: PrintTypeOptions): string;
+export declare function nameWithType(idl: IDLVariable, isVariadic?: boolean, isOptional?: boolean): string;
+export declare function quoteAttributeValues(attributes?: IDLExtendedAttribute[]): stringOrNone;
+export declare class IDLWriter {
+    protected printer: IndentedPrinter;
+    constructor(printer: IndentedPrinter);
+    print(line: stringOrNone): this;
+    pushIndent(): this;
+    popIndent(): this;
+    getOutput(): string[];
+    printReturnType(type: IDLType | IDLInterface | undefined): string;
+    printParameters(parameters: IDLParameter[]): string;
+    printConstructor(idl: IDLConstructor): this;
+    printConstant(idl: IDLConstant): this;
+    printProperty(idl: IDLProperty): this;
+    printExtendedAttributes(idl: IDLNode): this;
+    printSpacedTypeParameters(params: string[] | undefined): string;
+    printFunction(idl: IDLFunction): this;
+    printMethod(idl: IDLMethod): this;
+    printPackage(idl: IDLFile): this;
+    printImport(idl: IDLImport): this;
+    printNamespace(idl: IDLNamespace): this;
+    printCallback(idl: IDLCallback): this;
+    printScoped(idl: IDLEntry): this;
+    printInterfaceInherit(idl: IDLInterface): string;
+    printInterfaceHead(decl: IDLInterface): this;
+    printInterface(idl: IDLInterface): this;
+    printEnumMember(idl: IDLEnumMember): this;
+    printEnum(idl: IDLEnum, skipInitializers: boolean): this;
+    printTypedef(idl: IDLTypedef): this;
+    printIDL(idl: IDLNode, options?: Partial<IDLPrintOptions>): this;
+}
+export interface IDLPrintOptions {
+    verifyIdl: boolean;
+    disableEnumInitializers: boolean;
+    allowUnknownKinds: boolean;
+}
+export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOptions>): string;
+export {};
+//# sourceMappingURL=dump.d.ts.map

package/build/lib/src/idl/dump.js

@@ -0,0 +1,327 @@
+/*
+ * 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 { IndentedPrinter } from "../IndentedPrinter";
+import { isInterface, isOptionalType, isPrimitiveType, isContainerType, isReferenceType, isUnionType, isTypeParameterType, hasExtAttribute } from "./discriminators";
+import { IDLKeywords } from "./keywords";
+import { IDLExtendedAttributes, IDLKind } from "./node";
+import { IDLNullTypeName, IDLUndefinedType, IDLStringType } from "./stdlib";
+export function escapeIDLKeyword(name) {
+    return name + (IDLKeywords.has(name) ? "_" : "");
+}
+export function unescapeKeyword(name) {
+    if (name.endsWith("_")) {
+        const unwrapped = name.slice(0, -1);
+        if (IDLKeywords.has(unwrapped))
+            return unwrapped;
+    }
+    return name;
+}
+export function printType(type, options) {
+    if (!type)
+        throw new Error("Missing type");
+    if (isInterface(type))
+        return type.name;
+    if (isOptionalType(type)) {
+        if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
+            return `(${printType(type.type)} or ${IDLNullTypeName})`;
+        else if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull))
+            return `(${printType(type.type)} or ${IDLUndefinedType.name} or ${IDLNullTypeName})`;
+        else
+            return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    }
+    if (isPrimitiveType(type))
+        return type.name;
+    if (isContainerType(type))
+        return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
+    if (isReferenceType(type)) {
+        const maybeExtendedAttributes = type.extendedAttributes && type.extendedAttributes.length
+            ? `[${quoteAttributeValues(type.extendedAttributes)}] `
+            : '';
+        const maybeTypeArguments = type.typeArguments && type.typeArguments.length
+            ? '<' + type.typeArguments.map(t => printType(t)).join(', ') + '>'
+            : '';
+        let res = `${maybeExtendedAttributes}${type.name}${maybeTypeArguments}`;
+        if (maybeExtendedAttributes.length && (options === null || options === void 0 ? void 0 : options.bracketsAroundReferenceTypeWithExtAttrs))
+            return `(${res})`;
+        return res;
+    }
+    if (isUnionType(type))
+        return `(${type.types.map(it => printType(it)).join(" or ")})`;
+    if (isTypeParameterType(type))
+        return type.name;
+    throw new Error(`Cannot map type: ${IDLKind[type.kind]}`);
+}
+export function nameWithType(idl, isVariadic = false, isOptional = false) {
+    const type = printType(idl.type);
+    const variadic = isVariadic ? "..." : "";
+    const optional = isOptional ? "optional " : "";
+    return `${optional}${type}${variadic} ${escapeIDLKeyword(idl.name)}`;
+}
+const attributesToQuote = new Set([
+    IDLExtendedAttributes.Documentation,
+    IDLExtendedAttributes.DtsName,
+    IDLExtendedAttributes.DtsTag,
+    IDLExtendedAttributes.Import,
+    IDLExtendedAttributes.Interfaces,
+    IDLExtendedAttributes.TraceKey,
+    IDLExtendedAttributes.TypeParametersDefaults,
+]);
+export function quoteAttributeValues(attributes) {
+    return attributes === null || attributes === void 0 ? void 0 : attributes.map(it => {
+        let attr = it.name;
+        if (it.value) {
+            let value = it.value;
+            if (value.includes('"') && !value.includes("'"))
+                value = value.replaceAll('"', "'");
+            value = value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+            attr += `=${attributesToQuote.has(it.name) ? `"${value}"` : it.value}`;
+        }
+        return attr;
+    }).join(", ");
+}
+export class IDLWriter {
+    constructor(printer) {
+        this.printer = printer;
+    }
+    print(line) {
+        this.printer.print(line);
+        return this;
+    }
+    pushIndent() {
+        this.printer.pushIndent();
+        return this;
+    }
+    popIndent() {
+        this.printer.popIndent();
+        return this;
+    }
+    getOutput() {
+        return this.printer.getOutput();
+    }
+    printReturnType(type) {
+        return printType(type, { bracketsAroundReferenceTypeWithExtAttrs: true });
+    }
+    printParameters(parameters) {
+        var _a, _b;
+        return (_b = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.map(it => nameWithType(it, it.isVariadic, it.isOptional))) === null || _a === void 0 ? void 0 : _a.join(", ")) !== null && _b !== void 0 ? _b : "";
+    }
+    printConstructor(idl) {
+        return this.printExtendedAttributes(idl)
+            .print(`constructor(${this.printParameters(idl.parameters)});`);
+    }
+    printConstant(idl) {
+        return this.printExtendedAttributes(idl)
+            .print(`const ${nameWithType(idl)}${idl.value ? ` = ${idl.value}` : ``};`);
+    }
+    printProperty(idl) {
+        const staticMod = idl.isStatic ? "static " : "";
+        const readonlyMod = idl.isReadonly ? "readonly " : "";
+        return this.printExtendedAttributes(idl)
+            .print(`${staticMod}${readonlyMod}attribute ${nameWithType(idl)};`);
+    }
+    printExtendedAttributes(idl) {
+        var _a;
+        let typeParameters;
+        let typeArguments;
+        switch (idl.kind) {
+            case IDLKind.Interface:
+                typeParameters = idl.typeParameters;
+                break;
+            case IDLKind.Callback:
+            case IDLKind.Method:
+            case IDLKind.Callable:
+            case IDLKind.Constructor:
+                typeParameters = idl.typeParameters;
+                break;
+            case IDLKind.Typedef:
+                typeParameters = idl.typeParameters;
+                break;
+            case IDLKind.ReferenceType:
+                typeArguments = idl.typeArguments;
+                break;
+        }
+        const attributes = Array.from((_a = idl.extendedAttributes) !== null && _a !== void 0 ? _a : []);
+        if (idl.documentation) {
+            let docs = {
+                name: IDLExtendedAttributes.Documentation,
+                value: idl.documentation
+            };
+            attributes.unshift(docs);
+        }
+        // Deduplicate
+        const names = new Set();
+        const actualAttributes = [];
+        for (const attr of attributes) {
+            if (names.has(attr.name)) {
+                continue;
+            }
+            names.add(attr.name);
+            actualAttributes.push(attr);
+        }
+        if (actualAttributes.length == 0) {
+            return this;
+        }
+        const attrSpec = quoteAttributeValues(actualAttributes);
+        if (attrSpec)
+            this.print(`[${attrSpec}]`);
+        return this;
+    }
+    printSpacedTypeParameters(params) {
+        return params && params.length
+            ? '<' + params.join(', ') + '> '
+            : '';
+    }
+    printFunction(idl) {
+        var _a;
+        if ((_a = idl.name) === null || _a === void 0 ? void 0 : _a.startsWith("__")) {
+            console.log(`Ignore ${idl.name}`);
+            return this;
+        }
+        return this.printExtendedAttributes(idl)
+            .print(`${idl.isAsync ? "async " : ""}` +
+            `${this.printReturnType(idl.returnType)} ${idl.name}` +
+            `(${this.printParameters(idl.parameters)});`);
+    }
+    printMethod(idl) {
+        var _a;
+        if ((_a = idl.name) === null || _a === void 0 ? void 0 : _a.startsWith("__")) {
+            console.log(`Ignore ${idl.name}`);
+            return this;
+        }
+        return this.printExtendedAttributes(idl)
+            .print(`${idl.isStatic ? "static " : ""}${idl.isAsync ? "async " : ""}` +
+            `${this.printSpacedTypeParameters(idl.typeParameters)}` +
+            `${this.printReturnType(idl.returnType)} ${idl.name}` +
+            `(${this.printParameters(idl.parameters)});`);
+    }
+    printPackage(idl) {
+        const effectiveClause = idl.packageClause.filter(it => !!it);
+        if (!effectiveClause.length) {
+            return this;
+        }
+        return this.print(`package ${effectiveClause.join(".")};`);
+    }
+    printImport(idl) {
+        const effectiveClause = idl.clause.filter(it => !!it);
+        return this.print(`import ${effectiveClause.join(".") || "NULL_IMPORT"}${idl.name ? " as " : ""}${idl.name};`);
+    }
+    printNamespace(idl) {
+        this.printExtendedAttributes(idl)
+            .print(`namespace ${idl.name} {`)
+            .pushIndent();
+        idl.members.forEach(member => this.printIDL(member));
+        return this.popIndent().print("};");
+    }
+    printCallback(idl) {
+        return this.printExtendedAttributes(idl)
+            .print(`callback ${this.printSpacedTypeParameters(idl.typeParameters)}${idl.name} = ` +
+            `${this.printReturnType(idl.returnType)} (${this.printParameters(idl.parameters)});`);
+    }
+    printScoped(idl) {
+        if (idl.kind == IDLKind.Callback)
+            return this.printCallback(idl);
+        if (idl.kind === IDLKind.Interface)
+            return this.printInterface(idl);
+        throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
+    }
+    printInterfaceInherit(idl) {
+        if (idl.inheritance.length === 0) {
+            return "";
+        }
+        const types = idl.inheritance.map(type => printType(type));
+        return ": " + types.join(', ');
+    }
+    printInterfaceHead(decl) {
+        return this.print('interface ' +
+            this.printSpacedTypeParameters(decl.typeParameters) +
+            `${decl.name}${this.printInterfaceInherit(decl)} {`);
+    }
+    printInterface(idl) {
+        this.printExtendedAttributes(idl)
+            .printInterfaceHead(idl)
+            .pushIndent();
+        idl.constructors.forEach(it => this.printConstructor(it));
+        idl.constants.forEach(it => this.printConstant(it));
+        idl.properties.forEach(it => this.printProperty(it));
+        idl.methods.forEach(it => this.printMethod(it));
+        idl.callables.forEach(it => this.printFunction(it));
+        return this.popIndent().print("};");
+    }
+    printEnumMember(idl) {
+        const type = printType(idl.type);
+        const initializer = idl.initializer === undefined
+            ? ''
+            : ' = ' + (type === IDLStringType.name
+                ? `"${String(idl.initializer).replaceAll('"', "'")}"`
+                : idl.initializer);
+        return this.print(idl.documentation)
+            .printExtendedAttributes(idl)
+            .print(`${type} ${idl.name}${initializer};`);
+    }
+    printEnum(idl, skipInitializers) {
+        this.print(idl.documentation)
+            .printExtendedAttributes(idl);
+        if (skipInitializers) {
+            this.print(`enum ${idl.name} {`)
+                .pushIndent();
+            idl.elements.forEach(it => this.print(`${it.name} ${(it.initializer !== undefined ? " /* " + it.initializer + " */" : "")}`));
+            return this.popIndent().print("};");
+        }
+        else {
+            this.print(`dictionary ${idl.name} {`)
+                .pushIndent();
+            idl.elements.forEach(it => this.printEnumMember(it));
+            return this.popIndent().print("};");
+        }
+    }
+    printTypedef(idl) {
+        return this.print(idl.documentation)
+            .printExtendedAttributes(idl)
+            .print(`typedef ${this.printSpacedTypeParameters(idl.typeParameters)}${idl.name} = ` +
+            `${printType(idl.type)};`);
+    }
+    printIDL(idl, options) {
+        var _a;
+        if (idl.kind == IDLKind.Interface)
+            return this.printInterface(idl);
+        if (idl.kind == IDLKind.Enum)
+            return this.printEnum(idl, (_a = options === null || options === void 0 ? void 0 : options.disableEnumInitializers) !== null && _a !== void 0 ? _a : false);
+        if (idl.kind == IDLKind.Typedef)
+            return this.printTypedef(idl);
+        if (idl.kind == IDLKind.Callback)
+            return this.printCallback(idl);
+        if (idl.kind == IDLKind.Import)
+            return this.printImport(idl);
+        if (idl.kind == IDLKind.Namespace)
+            return this.printNamespace(idl);
+        if (idl.kind == IDLKind.Method)
+            return this.printMethod(idl);
+        if (idl.kind == IDLKind.Const)
+            return this.printConstant(idl);
+        if (options === null || options === void 0 ? void 0 : options.allowUnknownKinds) {
+            return this.print(`${IDLKind[idl.kind]} ${"name" in idl ? idl.name : ""}`);
+        }
+        else {
+            throw new Error(`unexpected kind: ${idl.kind}`);
+        }
+    }
+}
+export function toIDLString(file, options) {
+    const writer = new IDLWriter(new IndentedPrinter());
+    writer.printPackage(file);
+    file.entries.forEach(it => writer.printIDL(it, options));
+    return writer.getOutput().join("\n");
+}
+//# sourceMappingURL=dump.js.map

package/build/lib/src/idl/index.d.ts

@@ -0,0 +1,9 @@
+export * from './builders';
+export * from './discriminators';
+export * from './dump';
+export * from './keywords';
+export * from './node';
+export * from './stdlib';
+export * from './utils';
+export * from './visitors';
+//# sourceMappingURL=index.d.ts.map

package/build/lib/src/idl/index.js

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+export * from './builders';
+export * from './discriminators';
+export * from './dump';
+export * from './keywords';
+export * from './node';
+export * from './stdlib';
+export * from './utils';
+export * from './visitors';
+//# sourceMappingURL=index.js.map

package/build/lib/src/idl/keywords.d.ts

@@ -0,0 +1,2 @@
+export declare const IDLKeywords: Set<string>;
+//# sourceMappingURL=keywords.d.ts.map

package/build/lib/src/{options.js → idl/keywords.js}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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
@@ -12,5 +12,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
-//# sourceMappingURL=options.js.map
+export const IDLKeywords = new Set([
+    "attribute", "callback", "object", "toString",
+    'sequence', 'record', 'or', 'Int8Array',
+    'interface', 'number', 'undefined'
+]);
+//# sourceMappingURL=keywords.js.map