@idlizer/core 2.0.15

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

@@ -0,0 +1,4 @@
+import * as ts from "typescript";
+import { GenerateOptions, GenericVisitor } from "./options";
+export declare function generate<T>(inputDirs: string[], inputFile: string | undefined, outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => GenericVisitor<T>, options: GenerateOptions<T>): void;
+//# sourceMappingURL=idlize.d.ts.map

package/build/lib/src/idlize.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2024 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 * as ts from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+function readdir(dir) {
+    return fs.readdirSync(dir)
+        .map(elem => path.join(dir, elem));
+}
+export function generate(inputDirs, inputFile, outputDir, visitorFactory, options) {
+    var _a, _b, _c;
+    let input = inputFile ? [
+        path.join(inputDirs[0], inputFile)
+    ] : inputDirs.flatMap(it => readdir(path.resolve(it)));
+    // Build a program using the set of root file names in fileNames
+    let program = ts.createProgram(input.concat([path.join(__dirname, "../stdlib.d.ts")]), options.compilerOptions);
+    // Get the checker, we will use it to find more about classes
+    if (outputDir && !fs.existsSync(outputDir))
+        fs.mkdirSync(outputDir, { recursive: true });
+    const typeChecker = program.getTypeChecker();
+    (_a = options.onBegin) === null || _a === void 0 ? void 0 : _a.call(options, outputDir, typeChecker);
+    // Visit every sourceFile in the program
+    let cared = inputDirs.map(it => path.resolve(it));
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!cared.some(it => path.resolve(sourceFile.fileName).indexOf(it) >= 0)) {
+            // console.log("Ignore ", path.resolve(sourceFile.fileName) , "wrt", inputDirs)
+            continue;
+        }
+        if (inputFile && path.basename(sourceFile.fileName) != inputFile) {
+            continue;
+        }
+        // Walk the tree to search for classes
+        const visitor = visitorFactory(sourceFile, typeChecker);
+        const output = visitor.visitWholeFile();
+        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, output, outputDir, sourceFile);
+    }
+    (_c = options.onEnd) === null || _c === void 0 ? void 0 : _c.call(options, outputDir);
+    return;
+}
+//# sourceMappingURL=idlize.js.map

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

@@ -0,0 +1,34 @@
+export * from "./config";
+export * from "./idl";
+export * from "./library";
+export * from "./idlize";
+export * from "./inheritance";
+export * from "./Language";
+export * from "./languageSpecificKeywords";
+export * from "./options";
+export * from "./util";
+export * from "./rand_utils";
+export * from "./IndentedPrinter";
+export * from "./LibraryInterface";
+export * from "./LanguageWriters/LanguageWriter";
+export * from "./LanguageWriters/ArgConvertors";
+export * from "./LanguageWriters/common";
+export * from "./LanguageWriters/nameConvertor";
+export * from "./LanguageWriters/InteropConvertor";
+export * from "./LanguageWriters/convertors/CppConvertors";
+export * from "./LanguageWriters/writers/CJLanguageWriter";
+export * from "./LanguageWriters/writers/CLikeLanguageWriter";
+export * from "./LanguageWriters/writers/CppLanguageWriter";
+export * from "./LanguageWriters/writers/JavaLanguageWriter";
+export * from "./LanguageWriters/writers/TsLanguageWriter";
+export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./peer-generation/idl/IdlNameConvertor";
+export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/unions";
+export * from "./LanguageWriters";
+export * from "./peer-generation/ReferenceResolver";
+export * from "./peer-generation/idl/common";
+export { fromIDL } from "./from-idl/common";
+export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
+export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2024 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 "./config";
+export * from "./idl";
+export * from "./library";
+export * from "./idlize";
+export * from "./inheritance";
+export * from "./Language";
+export * from "./languageSpecificKeywords";
+export * from "./options";
+export * from "./util";
+export * from "./rand_utils";
+export * from "./IndentedPrinter";
+export * from "./LibraryInterface";
+export * from "./LanguageWriters/LanguageWriter";
+export * from "./LanguageWriters/ArgConvertors";
+export * from "./LanguageWriters/common";
+export * from "./LanguageWriters/nameConvertor";
+export * from "./LanguageWriters/InteropConvertor";
+export * from "./LanguageWriters/convertors/CppConvertors";
+export * from "./LanguageWriters/writers/CJLanguageWriter";
+export * from "./LanguageWriters/writers/CLikeLanguageWriter";
+export * from "./LanguageWriters/writers/CppLanguageWriter";
+export * from "./LanguageWriters/writers/JavaLanguageWriter";
+export * from "./LanguageWriters/writers/TsLanguageWriter";
+export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./peer-generation/idl/IdlNameConvertor";
+export * from "./peer-generation/PrimitiveType";
+export * from "./peer-generation/unions";
+export * from "./LanguageWriters";
+export * from "./peer-generation/ReferenceResolver";
+export * from "./peer-generation/idl/common";
+export { fromIDL } from "./from-idl/common";
+export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
+export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+export declare enum InheritanceRole {
+    Finalizable = 0,
+    PeerNode = 1,
+    Root = 2,
+    Heir = 3,
+    Standalone = 4
+}
+export declare function isCommonMethodOrSubclass(typeChecker: ts.TypeChecker, decl: ts.ClassDeclaration): boolean;
+export declare function determineInheritanceRole(name: string): InheritanceRole;
+export declare function determineParentRole(name: string | undefined, parent: string | undefined): InheritanceRole;
+export declare function isCommonMethod(name: string): boolean;
+export declare function isRoot(name: string): boolean;
+export declare function isStandalone(name: string): boolean;
+export declare function isHeir(name: string): boolean;
+//# sourceMappingURL=inheritance.d.ts.map

package/build/lib/src/inheritance.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2024 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 * as ts from "typescript";
+import { generatorConfiguration } from "./config";
+import { asString, heritageDeclarations, identName } from "./util";
+export var InheritanceRole;
+(function (InheritanceRole) {
+    InheritanceRole[InheritanceRole["Finalizable"] = 0] = "Finalizable";
+    InheritanceRole[InheritanceRole["PeerNode"] = 1] = "PeerNode";
+    InheritanceRole[InheritanceRole["Root"] = 2] = "Root";
+    InheritanceRole[InheritanceRole["Heir"] = 3] = "Heir";
+    InheritanceRole[InheritanceRole["Standalone"] = 4] = "Standalone";
+})(InheritanceRole || (InheritanceRole = {}));
+export function isCommonMethodOrSubclass(typeChecker, decl) {
+    var _a;
+    let name = identName(decl.name);
+    let isSubclass = isRoot(name);
+    (_a = decl.heritageClauses) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+        heritageDeclarations(typeChecker, it).forEach(it => {
+            let name = asString(it.name);
+            isSubclass = isSubclass || isRoot(name);
+            if (!ts.isClassDeclaration(it))
+                return isSubclass;
+            isSubclass = isSubclass || isCommonMethodOrSubclass(typeChecker, it);
+        });
+    });
+    return isSubclass;
+}
+export function determineInheritanceRole(name) {
+    if (generatorConfiguration().paramArray("rootComponents").includes(name))
+        return InheritanceRole.Root;
+    if (generatorConfiguration().paramArray("standaloneComponents").includes(name))
+        return InheritanceRole.Standalone;
+    return InheritanceRole.Heir;
+}
+export function determineParentRole(name, parent) {
+    if (!name)
+        throw new Error(`name must be known: ${parent}`);
+    if (parent === undefined) {
+        if (isStandalone(name))
+            return InheritanceRole.PeerNode;
+        if (isCommonMethod(name))
+            return InheritanceRole.PeerNode;
+        if (isRoot(name))
+            return InheritanceRole.PeerNode;
+        throw new Error(`Expected check to be exhaustive. node: ${name}`);
+    }
+    if (isRoot(parent))
+        return InheritanceRole.Root;
+    return InheritanceRole.Heir;
+}
+export function isCommonMethod(name) {
+    return name === "CommonMethod";
+}
+export function isRoot(name) {
+    return determineInheritanceRole(name) === InheritanceRole.Root;
+}
+export function isStandalone(name) {
+    return determineInheritanceRole(name) === InheritanceRole.Standalone;
+}
+export function isHeir(name) {
+    return determineInheritanceRole(name) === InheritanceRole.Heir;
+}
+//# sourceMappingURL=inheritance.js.map

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

@@ -0,0 +1,5 @@
+export declare const cppKeywords: Set<string>;
+export declare const CJKeywords: Set<string>;
+export declare const IDLKeywords: Set<string>;
+export declare const TSKeywords: Set<string>;
+//# sourceMappingURL=languageSpecificKeywords.d.ts.map

package/build/lib/src/languageSpecificKeywords.js

@@ -0,0 +1,51 @@
+// See https://en.cppreference.com/w/cpp/keyword.
+export const cppKeywords = new Set([
+    `alignas`, `alignof`, `and`,
+    `and_eq`, `asm`, `atomic_cancel`, `atomic_commit`,
+    `atomic_noexcept`, `auto`, `bitand`, `bitor`, `bool`,
+    `break`, `case`, `catch`, `char`, `char8_t`, `char16_t`,
+    `char32_t`, `class`, `compl`, `concept`, `const`, `consteval`,
+    `constexpr`, `constinit`, `const_cast`, `continue`, `co_await`,
+    `co_return`, `co_yield`, `decltype`, `default`, `delete`, `do`,
+    `double`, `dynamic_cast`, `else`, `enum`, `explicit`, `export`,
+    `extern`, `false`, `float`, `for`, `friend`, `goto`, `if`,
+    `inline`, `int`, `long`, `mutable`, `namespace`, `new`, `noexcept`,
+    `not`, `not_eq`, `nullptr`, `operator`, `or`, `or_eq`, `private`,
+    `protected`, `public`, `reflexpr`, `register`, `reinterpret_cast`,
+    `requires`, `return`, `short`, `signed`,
+    `sizeof`, `static`, `static_assert`, `static_cast`,
+    `struct`, `switch`, `synchronized`, `template`,
+    `this`, `thread_local`, `throw`, `true`, `try`,
+    `typedef`, `typeid`, `typename`, `union`,
+    `unsigned`, `using`, `virtual`, `void`,
+    `volatile`, `wchar_t`, `while`, `xor`,
+    `xor_eq`
+]);
+export const CJKeywords = new Set([
+    'Int8', 'Int16', 'Int32', 'Int64', 'IntNative',
+    'UInt8', 'UInt16', 'UInt32', 'UInt64', 'UIntNative',
+    'Float16', 'Float32', 'Float64', 'Rune',
+    'Bool', 'Unit', 'Nothing', 'struct',
+    'enum', 'This', 'package', 'import',
+    'class', 'interface', 'func', 'main',
+    'let', 'var', 'const', 'type', 'init',
+    'this', 'super', 'if', 'else', 'case',
+    'try', 'catch', 'finally', 'for', 'do',
+    'while', 'throw', 'return', 'continue',
+    'break', 'is', 'as', 'in', 'match',
+    'from', 'where', 'extend', 'spawn',
+    'synchronized', 'macro', 'quote', 'true',
+    'false', 'static', 'public', 'private',
+    'protected', 'override', 'redef', 'abstract',
+    'open', 'operator', 'foreign', 'inout',
+    'prop', 'mut', 'unsafe', 'get', 'set'
+]);
+export const IDLKeywords = new Set([
+    "attribute", "callback", "object", "toString",
+    'sequence', 'record', 'or', 'Int8Array',
+    'interface', 'number', 'undefined'
+]);
+export const TSKeywords = new Set([
+    "namespace"
+]);
+//# sourceMappingURL=languageSpecificKeywords.js.map

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

@@ -0,0 +1,67 @@
+import * as idl from './idl';
+export interface IDLLibrary {
+    readonly files: readonly IDLFile[];
+}
+export interface IDLFile {
+    fileName: string;
+    package?: idl.IDLPackage;
+    entities: idl.IDLNode[];
+}
+declare function createLibrary(files: IDLFile[]): IDLLibrary;
+declare function toLibrary(ii: Iterable<IDLFile>): IDLLibrary;
+declare function serializeParam(params: unknown): string;
+export interface LibraryQuery<A, R> {
+    fn: (x: A) => R;
+    key: string;
+    _reqBrand: unknown;
+}
+export interface LibraryReducer<R> {
+    fn: (x: IDLLibrary) => R;
+    key: string;
+    _redBrand: unknown;
+}
+declare function req<A, R>(key: string, fn: (x: A) => R): LibraryQuery<A, R>;
+declare function compose<B, R>(base: LibraryReducer<B>, next: LibraryQuery<B, R>): LibraryReducer<R>;
+declare function concat<A, R1, R2>(f: LibraryQuery<A, R1>, g: LibraryQuery<A, R2>): LibraryQuery<A, [R1, R2]>;
+declare class LensBuilder<R> {
+    private req;
+    private constructor();
+    static make<R>(r: LibraryReducer<R>): LensBuilder<R>;
+    pipe<T>(r: LibraryQuery<R, T>): LensBuilder<T>;
+    row<T>(key: string, f: (x: R) => T): LensBuilder<T>;
+    query(): LibraryReducer<R>;
+}
+export declare function lens<R>(r: LibraryReducer<R>): LensBuilder<R>;
+export type QueryType<T> = LibraryQuery<IDLLibrary, T> | LensBuilder<T>;
+export declare function query<T>(lib: IDLLibrary, input: QueryType<T>): T;
+interface EntitiesParams {
+    expandNamespaces?: boolean;
+    slipPackage?: boolean;
+}
+export declare const lib: {
+    createLibrary: typeof createLibrary;
+    toLibrary: typeof toLibrary;
+    lens: typeof lens;
+    query: typeof query;
+    select: {
+        files(): LibraryReducer<readonly IDLFile[]>;
+        nodes(params: EntitiesParams): LibraryQuery<readonly IDLFile[], idl.IDLNode[]>;
+        entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
+        interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
+        names(): LibraryQuery<idl.IDLNode[], string[]>;
+        name(name: string): LibraryReducer<idl.IDLNode[]>;
+    };
+    utils: {
+        idx: <T>(x: number) => LibraryQuery<T[], T | undefined>;
+        fst: <T_1>() => LibraryQuery<T_1[], T_1 | undefined>;
+        lst: <T_2>() => LibraryQuery<T_2[], T_2 | undefined>;
+    };
+    req: typeof req;
+    compose: typeof compose;
+    concat: typeof concat;
+    other: {
+        serializeParam: typeof serializeParam;
+    };
+};
+export {};
+//# sourceMappingURL=library.d.ts.map

package/build/lib/src/library.js

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2024 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 * as idl from './idl';
+function createLibrary(files) {
+    return {
+        files
+    };
+}
+function toLibrary(ii) {
+    return {
+        files: Array.from(ii)
+    };
+}
+function serializeParam(params) {
+    if (typeof params === 'undefined') {
+        return 'undefined';
+    }
+    if (typeof params === 'boolean') {
+        return params ? 'true' : 'false';
+    }
+    if (typeof params === 'string') {
+        return `"${params}"`;
+    }
+    if (typeof params === 'number') {
+        return params.toString();
+    }
+    if (typeof params === 'object') {
+        if (params === null) {
+            return 'null';
+        }
+        if (Array.isArray(params)) {
+            return '[' + params.map(serializeParam).join(', ') + ']';
+        }
+        const keys = Object.keys(params);
+        keys.sort();
+        return '{' +
+            keys.map((key) => {
+                if (typeof key !== 'string') {
+                    throw new Error(`Unsupported key! "${typeof key}"`);
+                }
+                const objectKey = key;
+                return `${key}=${serializeParam(params[objectKey])}`;
+            }).join(',')
+            + '}';
+    }
+    throw new Error(`Unsupported type! "${typeof params}"`);
+}
+const queryCache = new Map();
+function cached(key, f) {
+    return x => {
+        if (queryCache.has(key)) {
+            return queryCache.get(key);
+        }
+        const v = f(x);
+        queryCache.set(key, v);
+        return v;
+    };
+}
+function reduce(key, f) {
+    return {
+        fn: cached(key, f),
+        key,
+        _redBrand: {}
+    };
+}
+function req(key, fn) {
+    return {
+        fn,
+        key,
+        _reqBrand: {}
+    };
+}
+function compose(base, next) {
+    const key = base.key + '.' + next.key;
+    return {
+        fn: cached(key, x => next.fn(base.fn(x))),
+        key,
+        _redBrand: {}
+    };
+}
+function concat(f, g) {
+    const key = `$pair{${f.key},${g.key}}`;
+    return {
+        fn: cached(key, x => {
+            const r1 = f.fn(x);
+            const r2 = g.fn(x);
+            return [r1, r2];
+        }),
+        key,
+        _reqBrand: {}
+    };
+}
+class LensBuilder {
+    constructor(req) {
+        this.req = req;
+    }
+    static make(r) {
+        return new LensBuilder(r);
+    }
+    pipe(r) {
+        return new LensBuilder(compose(this.req, r));
+    }
+    row(key, f) {
+        return this.pipe(req(key, f));
+    }
+    query() {
+        return this.req;
+    }
+}
+export function lens(r) {
+    return LensBuilder.make(r);
+}
+export function query(lib, input) {
+    const request = input instanceof LensBuilder ? input.query() : input;
+    return request.fn(lib);
+}
+// UTILS
+const utils = {
+    idx: (x) => req('idx', xs => xs.at(x)),
+    fst: () => req('fst', xs => xs.at(0)),
+    lst: () => req('lst', xs => xs.at(-1)),
+};
+const select = {
+    files() {
+        return reduce('files', x => x.files);
+    },
+    nodes(params) {
+        const key = 'entities' + serializeParam(params);
+        function go(node) {
+            if (idl.isNamespace(node) && params.expandNamespaces) {
+                return node.members.flatMap(go);
+            }
+            if (idl.isPackage(node) && params.slipPackage) {
+                return [];
+            }
+            return [node];
+        }
+        return req(key, xs => {
+            return xs.flatMap(x => x.entities).flatMap(go);
+        });
+    },
+    entries() {
+        return req('entries', xs => xs.filter(idl.isEntry));
+    },
+    interfaces() {
+        return req('interfaces', it => it.filter(idl.isInterface));
+    },
+    names() {
+        return req('names', xs => xs.flatMap(x => idl.isNamedNode(x) ? [x.name] : []));
+    },
+    name(name) {
+        return reduce(`select.by.name.${name}`, lib => {
+            return lib.files.flatMap(it => {
+                return it.entities.flatMap(it => {
+                    if (idl.isNamedNode(it) && it.name === name) {
+                        return [it];
+                    }
+                    return [];
+                });
+            });
+        });
+    },
+};
+export const lib = {
+    createLibrary,
+    toLibrary,
+    lens,
+    query,
+    select,
+    utils,
+    req,
+    compose,
+    concat,
+    other: {
+        serializeParam
+    }
+};
+//# sourceMappingURL=library.js.map

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

@@ -0,0 +1,11 @@
+import * as ts from "typescript";
+export interface GenerateOptions<T> {
+    compilerOptions: ts.CompilerOptions;
+    onBegin?: (outDir: string, typeChecker: ts.TypeChecker) => void;
+    onSingleFile?: (entries: T, outDir: string, inputFile: ts.SourceFile) => void;
+    onEnd?: (outDir: string) => void;
+}
+export interface GenericVisitor<T> {
+    visitWholeFile(): T;
+}
+//# sourceMappingURL=options.d.ts.map

package/build/lib/src/options.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 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 {};
+//# sourceMappingURL=options.js.map

package/build/lib/src/peer-generation/PrimitiveType.d.ts

@@ -0,0 +1,24 @@
+export declare class PrimitiveType {
+    protected name: string;
+    protected isPointer: boolean;
+    constructor(name: string, isPointer?: boolean);
+    getText(): string;
+    toString(): string;
+}
+export declare class PrimitiveTypeList {
+    static get UndefinedTag(): string;
+    static get UndefinedRuntime(): string;
+    static get ObjectTag(): string;
+    readonly Int32: PrimitiveType;
+    readonly Int64: PrimitiveType;
+    readonly Boolean: PrimitiveType;
+    readonly Function: PrimitiveType;
+    readonly Undefined: PrimitiveType;
+    readonly Void: PrimitiveType;
+    readonly NativePointer: PrimitiveType;
+    readonly Tag: PrimitiveType;
+    readonly Materialized: PrimitiveType;
+    readonly CustomObject: PrimitiveType;
+}
+export declare const PrimitiveTypesInstance: PrimitiveTypeList;
+//# sourceMappingURL=PrimitiveType.d.ts.map

package/build/lib/src/peer-generation/PrimitiveType.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2024 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 { generatorConfiguration } from "../config";
+export class PrimitiveType {
+    constructor(name, isPointer = false) {
+        this.name = name;
+        this.isPointer = isPointer;
+    }
+    getText() {
+        return generatorConfiguration().param("TypePrefix") + this.name;
+    }
+    toString() {
+        return this.getText();
+    }
+}
+export class PrimitiveTypeList {
+    constructor() {
+        this.Int32 = new PrimitiveType(`Int32`);
+        this.Int64 = new PrimitiveType(`Int64`);
+        this.Boolean = new PrimitiveType(`Boolean`);
+        this.Function = new PrimitiveType(`Function`);
+        this.Undefined = new PrimitiveType(`Undefined`);
+        this.Void = new PrimitiveType(`Void`);
+        this.NativePointer = new PrimitiveType(`NativePointer`);
+        this.Tag = new PrimitiveType(`Tag`);
+        this.Materialized = new PrimitiveType(`Materialized`, true);
+        this.CustomObject = new PrimitiveType(`CustomObject`, true);
+    }
+    static get UndefinedTag() {
+        return "INTEROP_TAG_UNDEFINED";
+    }
+    static get UndefinedRuntime() {
+        return "INTEROP_RUNTIME_UNDEFINED";
+    }
+    static get ObjectTag() {
+        return "INTEROP_TAG_OBJECT";
+    }
+}
+export const PrimitiveTypesInstance = new PrimitiveTypeList();
+//# sourceMappingURL=PrimitiveType.js.map

package/build/lib/src/peer-generation/ReferenceResolver.d.ts

@@ -0,0 +1,9 @@
+import * as idl from '../idl';
+export interface ReferenceResolver {
+    resolveTypeReference(type: idl.IDLReferenceType, pointOfView?: idl.IDLEntry, rootEntries?: idl.IDLEntry[]): idl.IDLEntry | undefined;
+    toDeclaration(type: idl.IDLNode): idl.IDLNode;
+}
+export declare function createEmptyReferenceResolver(): ReferenceResolver;
+/** Please do not store any global instances */
+export declare function createAlternativeReferenceResolver(mainResolver: ReferenceResolver, alternatives: Map<string, idl.IDLEntry>): ReferenceResolver;
+//# sourceMappingURL=ReferenceResolver.d.ts.map