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

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

@@ -0,0 +1,15 @@
+import { IDLNodeInitializer } from "./builders";
+import { IDLNode, IDLFunction } from "./node";
+type IDLNodeVisitorVoid = (node: IDLNode) => void;
+type IDLNodeVisitorValue = (node: IDLNode) => () => void;
+type IDLNodeVisitor = IDLNodeVisitorVoid | IDLNodeVisitorValue;
+export declare function forEachChild(node: IDLNode, cbEnter: IDLNodeVisitor, cbLeave?: (entry: IDLNode) => void): void;
+/** Updates tree in place! */
+export declare function updateEachChild(node: IDLNode, op: (node: IDLNode) => IDLNode, cbLeave?: (entry: IDLNode) => void): IDLNode;
+export declare function cloneNodeInitializer(other: IDLNodeInitializer): IDLNodeInitializer;
+export declare function visitChildren(node: IDLNode, mutator: (node: IDLNode) => IDLNode): IDLNode;
+export declare function linkParentBack<T extends IDLNode>(node: T): T;
+export declare function clone<T extends IDLNode>(node: T): T;
+export declare function forEachFunction(node: IDLNode, cb: (node: IDLFunction) => void): void;
+export {};
+//# sourceMappingURL=visitors.d.ts.map

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

@@ -0,0 +1,593 @@
+/*
+ * 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 { generateSyntheticUnionName } from "../peer-generation/idl/common";
+import { createInterface, createFile, createNamespace, createMethod, createCallable, createCallback, createConstructor, createUnionType, createOptionalType, createConstant, createEnum, createEnumMember, createProperty, createParameter, createTypedef, createContainerType, createReferenceType, createImport, createTypeParameterReference, createVersion } from "./builders";
+import { isType, isNamespace, isInterface, isMethod, isCallback, isTypedef, isEnum, isImport, isVersion, isConstant, isConstructor, isProperty, isCallable, isFile, isReferenceType, isParameter, isUnionType, isOptionalType, isEnumMember, isPrimitiveType, isContainerType, isTypeParameterType } from "./discriminators";
+import { IDLKind } from "./node";
+export function forEachChild(node, cbEnter, cbLeave) {
+    var _a, _b, _c;
+    const cleanup = cbEnter(node);
+    switch (node.kind) {
+        case IDLKind.File:
+            node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        case IDLKind.Namespace:
+            node.members.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        case IDLKind.Interface: {
+            let concrete = node;
+            concrete.inheritance.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.constructors.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.Method:
+        case IDLKind.Callable:
+        case IDLKind.Callback:
+        case IDLKind.Constructor: {
+            let concrete = node;
+            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            if (concrete.returnType)
+                forEachChild(concrete.returnType, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.UnionType: {
+            let concrete = node;
+            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.OptionalType: {
+            let concrete = node;
+            forEachChild(concrete.type, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.Const: {
+            forEachChild(node.type, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.Enum: {
+            node.elements.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.Property: {
+            forEachChild(node.type, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.Parameter: {
+            const concrete = node;
+            if (concrete.type)
+                forEachChild(concrete.type, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.Typedef: {
+            forEachChild(node.type, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.ContainerType: {
+            node.elementType.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.ReferenceType: {
+            (_c = node.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.TypeParameterType:
+        case IDLKind.EnumMember:
+        case IDLKind.Import:
+        case IDLKind.PrimitiveType:
+        case IDLKind.Version:
+            break;
+        default: {
+            throw new Error(`Unhandled ${node.kind}`);
+        }
+    }
+    cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
+    cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+}
+/** Updates tree in place! */
+export function updateEachChild(node, op, cbLeave) {
+    var _a;
+    const old = node;
+    node = op(old);
+    if (node.kind !== old.kind && !(isType(old) && isType(node))) {
+        throw new Error("Kinds must be the same!");
+    }
+    switch (node.kind) {
+        case IDLKind.File: {
+            const concrete = node;
+            concrete.entries = concrete.entries.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Namespace: {
+            const concrete = node;
+            concrete.members = concrete.members.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Interface: {
+            const concrete = node;
+            concrete.inheritance = concrete.inheritance.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.constructors = concrete.constructors.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.properties = concrete.properties.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.methods = concrete.methods.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.callables = concrete.callables.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Method:
+        case IDLKind.Callable:
+        case IDLKind.Callback:
+        case IDLKind.Constructor: {
+            const concrete = node;
+            concrete.parameters = concrete.parameters.map((it) => updateEachChild(it, op, cbLeave));
+            if (concrete.returnType) {
+                concrete.returnType = updateEachChild(concrete.returnType, op, cbLeave);
+            }
+            break;
+        }
+        case IDLKind.UnionType: {
+            const concrete = node;
+            concrete.types = concrete.types.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.OptionalType: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Const: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Enum: {
+            const concrete = node;
+            concrete.elements = concrete.elements.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Property: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Parameter: {
+            const concrete = node;
+            if (concrete.type)
+                concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Typedef: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.ContainerType: {
+            const concrete = node;
+            concrete.elementType = concrete.elementType.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.ReferenceType: {
+            const concrete = node;
+            concrete.typeArguments = (_a = concrete.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.TypeParameterType:
+        case IDLKind.EnumMember:
+        case IDLKind.Import:
+        case IDLKind.PrimitiveType:
+        case IDLKind.Version:
+            break;
+        default: {
+            throw new Error(`Unhandled ${node.kind}`);
+        }
+    }
+    if (cbLeave) {
+        cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
+    }
+    return node;
+}
+export function cloneNodeInitializer(other) {
+    return {
+        documentation: other.documentation,
+        extendedAttributes: other.extendedAttributes,
+        fileName: other.fileName,
+        nameLocation: other.nameLocation,
+        nodeLocation: other.nodeLocation,
+        valueLocation: other.valueLocation,
+    };
+}
+export function visitChildren(node, mutator) {
+    function track(visitor) {
+        let changed = false;
+        let factory = visitor((node) => {
+            const newNode = mutator(node);
+            changed || (changed = node !== newNode);
+            return newNode;
+        });
+        return changed ? factory() : node;
+    }
+    function assert(predicate) {
+        return (node) => {
+            if (predicate(node))
+                return node;
+            throw new Error(`Unexpected node kind ${node.kind}`);
+        };
+    }
+    function isNamespaceMember(node) {
+        return isNamespace(node)
+            || isInterface(node)
+            || isMethod(node) && node.isFree
+            || isCallback(node)
+            || isTypedef(node)
+            || isEnum(node)
+            || isImport(node)
+            || isVersion(node)
+            || isConstant(node);
+    }
+    function isInterfaceMember(node) {
+        return isConstructor(node)
+            || isMethod(node)
+            || isConstant(node)
+            || isProperty(node)
+            || isCallable(node);
+    }
+    if (isFile(node)) {
+        return track((op) => {
+            const entries = node.entries.map(op).map(assert(isNamespaceMember));
+            return () => createFile(entries, node.fileName, node.packageClause, cloneNodeInitializer(node));
+        });
+    }
+    if (isNamespace(node)) {
+        return track((op) => {
+            const members = node.members.map(op).map(assert(isNamespaceMember));
+            return () => createNamespace(node.name, members, cloneNodeInitializer(node));
+        });
+    }
+    if (isInterface(node)) {
+        return track((op) => {
+            const inheritance = node.inheritance.map(op).map(assert(isReferenceType));
+            const members = [
+                ...node.constructors,
+                ...node.callables,
+                ...node.properties,
+                ...node.methods,
+                ...node.constants,
+            ].map(op).map(assert(isInterfaceMember));
+            return () => createInterface(node.name, node.subkind, inheritance, members.filter(isConstructor), members.filter(isConstant), members.filter(isProperty), members.filter(isMethod), members.filter(isCallable), node.typeParameters, cloneNodeInitializer(node));
+        });
+    }
+    if (isMethod(node)) {
+        return track(op => {
+            const parameters = node.parameters.map(op).map(assert(isParameter));
+            const returnType = assert(isType)(op(node.returnType));
+            return () => createMethod(node.name, parameters, returnType, { isAsync: node.isAsync, isFree: node.isFree, isOptional: node.isOptional, isStatic: node.isStatic }, cloneNodeInitializer(node), node.typeParameters);
+        });
+    }
+    if (isCallable(node)) {
+        return track(op => {
+            const parameters = node.parameters.map(op).map(assert(isParameter));
+            const returnType = assert(isType)(op(node.returnType));
+            return () => createCallable(node.name, parameters, returnType, { isAsync: node.isAsync, isStatic: node.isStatic }, cloneNodeInitializer(node));
+        });
+    }
+    if (isCallback(node)) {
+        return track(op => {
+            const parameters = node.parameters.map(op).map(assert(isParameter));
+            const returnType = assert(isType)(op(node.returnType));
+            return () => createCallback(node.name, parameters, returnType, cloneNodeInitializer(node), node.typeParameters);
+        });
+    }
+    if (isConstructor(node)) {
+        return track(op => {
+            const parameters = node.parameters.map(op).map(assert(isParameter));
+            const returnType = node.returnType ? assert(isType)(op(node.returnType)) : undefined;
+            return () => createConstructor(parameters, returnType, cloneNodeInitializer(node));
+        });
+    }
+    if (isUnionType(node)) {
+        return track(op => {
+            const types = node.types.map(op).map(assert(isType));
+            const name = types.some((it, index) => it !== node.types[index])
+                ? generateSyntheticUnionName(types)
+                : node.name;
+            return () => createUnionType(types, name, cloneNodeInitializer(node));
+        });
+    }
+    if (isOptionalType(node)) {
+        return track(op => {
+            const t = assert(isType)(op(node.type));
+            return () => createOptionalType(t, cloneNodeInitializer(node));
+        });
+    }
+    if (isConstant(node)) {
+        return track(op => {
+            const t = assert(isType)(op(node.type));
+            return () => createConstant(node.name, t, node.value, cloneNodeInitializer(node));
+        });
+    }
+    if (isEnum(node)) {
+        return track(op => {
+            const elements = node.elements.map(op).map(assert(isEnumMember));
+            return () => createEnum(node.name, elements, cloneNodeInitializer(node));
+        });
+    }
+    if (isEnumMember(node)) {
+        return track(op => {
+            const t = assert(isPrimitiveType)(op(node.type));
+            return () => createEnumMember(node.name, node.parent /* TODO seems strange in that context */, t, node.initializer, cloneNodeInitializer(node));
+        });
+    }
+    if (isProperty(node)) {
+        return track(op => {
+            const t = assert(isType)(op(node.type));
+            return () => createProperty(node.name, t, node.isReadonly, node.isStatic, node.isOptional, cloneNodeInitializer(node));
+        });
+    }
+    if (isParameter(node)) {
+        return track(op => {
+            const t = assert(isType)(op(node.type));
+            return () => createParameter(node.name, t, node.isOptional, node.isVariadic, cloneNodeInitializer(node));
+        });
+    }
+    if (isTypedef(node)) {
+        return track(op => {
+            const t = assert(isType)(op(node.type));
+            return () => createTypedef(node.name, t, node.typeParameters, cloneNodeInitializer(node));
+        });
+    }
+    if (isContainerType(node)) {
+        return track(op => {
+            const elementType = node.elementType.map(op).map(assert(isType));
+            return () => createContainerType(node.containerKind, elementType, cloneNodeInitializer(node));
+        });
+    }
+    if (isReferenceType(node)) {
+        return track(op => {
+            var _a;
+            const typeArguments = (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(op).map(assert(isType));
+            return () => createReferenceType(node.name, typeArguments, cloneNodeInitializer(node));
+        });
+    }
+    if (isTypeParameterType(node)
+        || isImport(node)
+        || isPrimitiveType(node)
+        || isVersion(node)) {
+        return node;
+    }
+    throw new Error(`Not implemented`);
+}
+export function linkParentBack(node) {
+    const parentStack = [];
+    updateEachChild(node, (node) => {
+        if (isPrimitiveType(node)) {
+            return node;
+        }
+        if (parentStack.length) {
+            const top = parentStack[parentStack.length - 1];
+            if (node.parent !== undefined && node.parent !== top) {
+                node = clone(node);
+            }
+            node.parent = top;
+        }
+        parentStack.push(node);
+        return node;
+    }, (node) => {
+        if (isPrimitiveType(node)) {
+            return;
+        }
+        parentStack.pop();
+    });
+    return node;
+}
+export function clone(node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    const make = (newnode) => {
+        if (node.nodeLocation) {
+            newnode.nodeLocation = node.nodeLocation;
+        }
+        if (node.nameLocation) {
+            newnode.nameLocation = node.nameLocation;
+        }
+        if (node.valueLocation) {
+            newnode.valueLocation = node.valueLocation;
+        }
+        return newnode;
+    };
+    const get = (node) => node;
+    switch (node.kind) {
+        case IDLKind.Interface: {
+            const entry = get(node);
+            return make(createInterface(entry.name, entry.subkind, (_a = entry.inheritance) === null || _a === void 0 ? void 0 : _a.map(clone), (_b = entry.constructors) === null || _b === void 0 ? void 0 : _b.map(clone), entry.constants.map(clone), entry.properties.map(clone), entry.methods.map(clone), entry.callables.map(clone), (_c = entry.typeParameters) === null || _c === void 0 ? void 0 : _c.map(it => it), {
+                documentation: node.documentation,
+                extendedAttributes: (_d = node.extendedAttributes) === null || _d === void 0 ? void 0 : _d.slice(),
+                fileName: node.fileName
+            }));
+        }
+        case IDLKind.Import: {
+            const entry = get(node);
+            return make(createImport(entry.clause, entry.name, {
+                documentation: entry.documentation,
+                extendedAttributes: (_e = entry.extendedAttributes) === null || _e === void 0 ? void 0 : _e.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Callback: {
+            const entry = get(node);
+            return make(createCallback(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                documentation: entry.documentation,
+                extendedAttributes: (_f = entry.extendedAttributes) === null || _f === void 0 ? void 0 : _f.slice(),
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Const: {
+            const entry = get(node);
+            return make(createConstant(entry.name, clone(entry.type), entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: (_g = entry.extendedAttributes) === null || _g === void 0 ? void 0 : _g.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Property: {
+            const entry = get(node);
+            return make(createProperty(entry.name, clone(entry.type), entry.isReadonly, entry.isStatic, entry.isOptional, {
+                documentation: entry.documentation,
+                extendedAttributes: (_h = entry.extendedAttributes) === null || _h === void 0 ? void 0 : _h.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Parameter: {
+            const entry = get(node);
+            return make(createParameter(entry.name, clone(entry.type), entry.isOptional, entry.isVariadic, {
+                documentation: entry.documentation,
+                extendedAttributes: (_j = entry.extendedAttributes) === null || _j === void 0 ? void 0 : _j.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Method: {
+            const entry = get(node);
+            return make(createMethod(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isFree: entry.isFree,
+                isOptional: entry.isOptional,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: (_k = entry.extendedAttributes) === null || _k === void 0 ? void 0 : _k.slice(),
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Callable: {
+            const entry = get(node);
+            return make(createCallable(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: (_l = entry.extendedAttributes) === null || _l === void 0 ? void 0 : _l.slice(),
+                fileName: entry.documentation
+            }, entry.typeParameters));
+        }
+        case IDLKind.Constructor: {
+            const entry = get(node);
+            return make(createConstructor(entry.parameters.map(clone), entry.returnType ? clone(entry.returnType) : undefined, {
+                documentation: entry.documentation,
+                extendedAttributes: (_m = entry.extendedAttributes) === null || _m === void 0 ? void 0 : _m.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Enum: {
+            const entry = get(node);
+            const cloned = createEnum(entry.name, entry.elements.map(clone), {
+                documentation: entry.documentation,
+                extendedAttributes: (_o = entry.extendedAttributes) === null || _o === void 0 ? void 0 : _o.slice(),
+                fileName: entry.fileName
+            });
+            cloned.elements.forEach(it => {
+                it.parent = cloned;
+            });
+            return make(cloned);
+        }
+        case IDLKind.EnumMember: {
+            const entry = get(node);
+            return make(createEnumMember(entry.name, entry.parent, clone(entry.type), entry.initializer, {
+                documentation: entry.documentation,
+                extendedAttributes: (_p = entry.extendedAttributes) === null || _p === void 0 ? void 0 : _p.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Typedef: {
+            const entry = get(node);
+            return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, {
+                documentation: entry.documentation,
+                extendedAttributes: (_q = entry.extendedAttributes) === null || _q === void 0 ? void 0 : _q.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.PrimitiveType: {
+            return node;
+        }
+        case IDLKind.ContainerType: {
+            const type = get(node);
+            return make(createContainerType(type.containerKind, type.elementType.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: (_r = type.extendedAttributes) === null || _r === void 0 ? void 0 : _r.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.ReferenceType: {
+            const type = get(node);
+            return make(createReferenceType(type.name, (_s = type.typeArguments) === null || _s === void 0 ? void 0 : _s.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: (_t = type.extendedAttributes) === null || _t === void 0 ? void 0 : _t.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnionType: {
+            const type = get(node);
+            return make(createUnionType(type.types.map(clone), type.name, {
+                documentation: type.documentation,
+                extendedAttributes: (_u = type.extendedAttributes) === null || _u === void 0 ? void 0 : _u.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.TypeParameterType: {
+            const type = get(node);
+            return make(createTypeParameterReference(type.name, {
+                documentation: type.documentation,
+                extendedAttributes: (_v = type.extendedAttributes) === null || _v === void 0 ? void 0 : _v.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.OptionalType: {
+            const type = get(node);
+            return make(createOptionalType(clone(type.type), {
+                documentation: type.documentation,
+                extendedAttributes: (_w = type.extendedAttributes) === null || _w === void 0 ? void 0 : _w.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.Version: {
+            const entry = get(node);
+            return make(createVersion(entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: (_x = entry.extendedAttributes) === null || _x === void 0 ? void 0 : _x.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Namespace: {
+            const ns = get(node);
+            return make(createNamespace(ns.name, ns.members.map(clone), {
+                documentation: ns.documentation,
+                extendedAttributes: (_y = ns.extendedAttributes) === null || _y === void 0 ? void 0 : _y.slice(),
+                fileName: ns.fileName
+            }));
+        }
+        case IDLKind.File: {
+            const file = get(node);
+            return make(createFile(file.entries.map(clone), file.fileName, file.packageClause, {
+                documentation: file.documentation,
+                extendedAttributes: (_z = file.extendedAttributes) === null || _z === void 0 ? void 0 : _z.slice(),
+                fileName: file.fileName
+            }));
+        }
+    }
+}
+export function forEachFunction(node, cb) {
+    forEachChild(node, child => {
+        if (child.kind === IDLKind.Method || child.kind === IDLKind.Callable)
+            cb(child);
+    });
+}
+//# sourceMappingURL=visitors.js.map

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

@@ -4,6 +4,7 @@ export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
 export * from "./inheritance";
+export * from "./inputPaths";
 export * from "./Language";
 export * from "./languageSpecificKeywords";
 export * from "./util";
@@ -37,7 +38,6 @@ export * from "./peer-generation/PeerLibrary";
 export * from "./peer-generation/PeerFile";
 export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
-export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
@@ -46,17 +46,19 @@ export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./peer-generation/ConflictingDeclarations";
+export * from "./peer-generation/toDeclaration";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";
 export * from "./transformers/OnSerializeTransformer";
+export * from "./transformers/IdlTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { parseIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { parseIDLFile, addSyntheticType, resolveSyntheticType, compareNodes, toIdlType } from "./from-idl/deserialize";
 export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, ConfigTypeInfer, ConfigSchema, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -18,6 +18,7 @@ export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
 export * from "./inheritance";
+export * from "./inputPaths";
 export * from "./Language";
 export * from "./languageSpecificKeywords";
 export * from "./util";
@@ -51,7 +52,6 @@ export * from "./peer-generation/PeerLibrary";
 export * from "./peer-generation/PeerFile";
 export * from "./peer-generation/PeerClass";
 export * from "./peer-generation/PeerMethod";
-export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
@@ -60,17 +60,19 @@ export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
 export * from "./peer-generation/ConflictingDeclarations";
+export * from "./peer-generation/toDeclaration";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";
 export * from "./transformers/OnSerializeTransformer";
+export * from "./transformers/IdlTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export * from "./from-idl/IDLLinter";
 export { fromIDL, scanIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { parseIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { parseIDLFile, addSyntheticType, resolveSyntheticType, compareNodes, toIdlType } from "./from-idl/deserialize";
 export { Parser, FatalParserException } from "./from-idl/parser";
 export { D, inspectSchema } from './configDescriber';
 //# sourceMappingURL=index.js.map