@idlizer/core 2.1.0 → 2.1.2

package/build/lib/src/config.js

@@ -16,6 +16,11 @@ import { D } from "./configDescriber";
 const T = {
     stringArray: () => D.array(D.string())
 };
+export const ModuleConfigurationSchema = D.object({
+    name: D.string(),
+    packages: T.stringArray(),
+    useFoldersLayout: D.maybe(D.boolean()),
+});
 export const CoreConfigurationSchema = D.object({
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
@@ -28,6 +33,8 @@ export const CoreConfigurationSchema = D.object({
     forceMaterialized: T.stringArray(),
     forceCallback: T.stringArray(),
     forceContext: T.stringArray(),
+    moduleName: D.string(),
+    modules: D.map(D.string(), ModuleConfigurationSchema)
 });
 export const defaultCoreConfiguration = {
     TypePrefix: "",
@@ -41,6 +48,8 @@ export const defaultCoreConfiguration = {
     forceMaterialized: [],
     forceCallback: [],
     forceContext: [],
+    moduleName: "",
+    modules: new Map(),
 };
 let currentConfig = defaultCoreConfiguration;
 export function setDefaultConfiguration(config) {

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

@@ -115,8 +115,8 @@ export class CustomPrintVisitor {
             this.currentInterface = node;
             this.pushIndent();
             node.constructors.map(it => this.visit(it));
-            node.properties.filter(it => !it.isStatic).map(it => this.visit(it));
-            node.methods.filter(it => !it.isStatic).map(it => this.visit(it));
+            node.properties.map(it => this.visit(it));
+            node.methods.map(it => this.visit(it));
             node.callables.map(it => this.visit(it));
             let verbatim = getVerbatimDts(node);
             if (verbatim) {

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

@@ -280,6 +280,7 @@ export declare const IDLThisType: IDLPrimitiveType;
 export declare const IDLDate: IDLPrimitiveType;
 export declare const IDLBufferType: IDLPrimitiveType;
 export declare const IDLUint8ArrayType: IDLContainerType;
+export declare const IDLSerializerBuffer: IDLPrimitiveType;
 export declare const IDLFunctionType: IDLPrimitiveType;
 export declare const IDLLengthType: IDLPrimitiveType;
 export declare const IDLCustomObjectType: IDLPrimitiveType;
@@ -294,8 +295,8 @@ export declare function linkParentBack<T extends IDLNode>(node: T): T;
 export declare function getNamespacesPathFor(entry: IDLEntry): IDLNamespace[];
 export declare function getFileFor(entry: IDLNode): IDLFile | undefined;
 export declare function isEqualByQualifedName(a?: IDLEntry, b?: IDLEntry): boolean;
-export declare function getPackageClause(entry: IDLFile | IDLEntry): string[];
-export declare function getPackageName(entry: IDLFile | IDLEntry): string;
+export declare function getPackageClause(entry: IDLNode): string[];
+export declare function getPackageName(node: IDLNode): string;
 export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): boolean;
 export declare function getNamespaceName(a: IDLEntry): string;
 export declare function getFQName(a: IDLEntry): string;
@@ -357,6 +358,7 @@ export declare function printCallback(idl: IDLCallback): PrintedLine[];
 export declare function printScoped(idl: IDLEntry): PrintedLine[];
 export declare function printInterface(idl: IDLInterface): PrintedLine[];
 export declare function getSuperType(idl: IDLInterface): IDLReferenceType | undefined;
+export declare function getSuperTypes(idl: IDLInterface): IDLReferenceType[] | undefined;
 export declare function hasSuperType(idl: IDLInterface): boolean;
 export declare function printEnumMember(idl: IDLEnumMember): PrintedLine[];
 export declare function printEnum(idl: IDLEnum, skipInitializers: boolean): PrintedLine[];

package/build/lib/src/idl.js

@@ -326,6 +326,7 @@ export const IDLThisType = createPrimitiveType('this');
 export const IDLDate = createPrimitiveType('date');
 export const IDLBufferType = createPrimitiveType('buffer');
 export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
+export const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 // Stub for IdlPeerLibrary
 export const IDLFunctionType = createPrimitiveType('Function');
 export const IDLLengthType = createPrimitiveType('Length');
@@ -391,8 +392,8 @@ export function getPackageClause(entry) {
     let file = getFileFor(entry);
     return (file === null || file === void 0 ? void 0 : file.packageClause) || [];
 }
-export function getPackageName(entry) {
-    return getPackageClause(entry).join(".");
+export function getPackageName(node) {
+    return getPackageClause(node).join(".");
 }
 export function isInPackage(entry, packageName, exactMatch = false) {
     const entryPackageName = getPackageName(entry);
@@ -789,6 +790,16 @@ export function getSuperType(idl) {
     const parent = idl.inheritance[0];
     return parent && parent !== IDLTopType ? parent : undefined;
 }
+export function getSuperTypes(idl) {
+    if (!idl.inheritance)
+        return undefined;
+    if (idl.inheritance[0] == IDLTopType) {
+        return idl.inheritance.length == 1 ? undefined : idl.inheritance.slice(1);
+    }
+    else {
+        return idl.inheritance.length == 0 ? undefined : idl.inheritance;
+    }
+}
 export function hasSuperType(idl) {
     return isDefined(getSuperType(idl));
 }

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

@@ -16,6 +16,7 @@ export interface GenerateVisitor<T> {
     }): T;
 }
 export declare function generate<T>(inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
 export declare function isInIdlize(entry: idl.IDLEntry | idl.IDLFile): boolean;
 export declare function isInIdlizeInterop(entry: idl.IDLEntry | idl.IDLFile): boolean;
 export declare function isInIdlizeInternal(entry: idl.IDLEntry | idl.IDLFile): boolean;

package/build/lib/src/idlize.js

@@ -124,14 +124,15 @@ export function generate(inputFiles, outputDir, visitorFactory, options) {
         console.log("Generation completed.");
     }
 }
+export const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
 export function isInIdlize(entry) {
     return idl.isInPackage(entry, "idlize");
 }
 export function isInIdlizeInterop(entry) {
-    return idl.isInPackage(entry, "idlize.internal.interop");
+    return idl.isInPackage(entry, `${PACKAGE_IDLIZE_INTERNAL}.interop`);
 }
 export function isInIdlizeInternal(entry) {
-    return idl.isInPackage(entry, "idlize.internal");
+    return idl.isInPackage(entry, PACKAGE_IDLIZE_INTERNAL);
 }
 export function isInIdlizeStdlib(entry) {
     return idl.isInPackage(entry, "idlize.stdlib");

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

@@ -37,8 +37,10 @@ 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";
 export * from "./peer-generation/isStructureType";
+export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

package/build/lib/src/index.js

@@ -51,8 +51,10 @@ 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";
 export * from "./peer-generation/isStructureType";
+export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";

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

@@ -10253,7 +10253,6 @@ export declare const lenses: {
 };
 export declare class PeerLibrary implements LibraryInterface {
     language: Language;
-    libraryPackages: string[] | undefined;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
     get globals(): GlobalScopeDeclarations[];
@@ -10266,7 +10265,7 @@ export declare class PeerLibrary implements LibraryInterface {
     get buildersToGenerate(): BuilderClass[];
     readonly materializedClasses: Map<string, MaterializedClass>;
     get materializedToGenerate(): MaterializedClass[];
-    constructor(language: Language, libraryPackages: string[] | undefined);
+    constructor(language: Language);
     name: string;
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
@@ -10283,7 +10282,6 @@ export declare class PeerLibrary implements LibraryInterface {
     mapType(type: idl.IDLType): string;
     resolveTypeReference(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
     private resolveTypeReferenceScoped;
-    hasInLibrary(entry: idl.IDLEntry): boolean;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     private customConvertor;

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

@@ -16,7 +16,7 @@ import { warn } from 'console';
 import * as idl from '../idl';
 import { Language } from '../Language';
 import { createLanguageWriter } from '../LanguageWriters';
-import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, } from "../LanguageWriters/ArgConvertors";
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -29,6 +29,7 @@ import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
 import { isInIdlizeInternal } from '../idlize';
+import { isInCurrentModule } from './modules';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -42,6 +43,8 @@ export const lenses = {
             };
             const next = queue.pop();
             next.forEach(node => {
+                if (!isInCurrentModule(node))
+                    return;
                 if (idl.isNamespace(node)) {
                     queue.push(node.members);
                 }
@@ -69,7 +72,9 @@ export class PeerLibrary {
         };
         return this._cachedIdlLibrary;
     }
-    get globals() { return query(this.asIDLLibrary(), lenses.globals); }
+    get globals() {
+        return query(this.asIDLLibrary(), lenses.globals);
+    }
     initSyntheticEntries(file) {
         this._syntheticFile = file;
     }
@@ -82,9 +87,8 @@ export class PeerLibrary {
     get materializedToGenerate() {
         return Array.from(this.materializedClasses.values()).filter(it => it.needBeGenerated);
     }
-    constructor(language, libraryPackages) {
+    constructor(language) {
         this.language = language;
-        this.libraryPackages = libraryPackages;
         this.layout = LayoutManager.Empty();
         this._syntheticFile = idl.createFile([]);
         this.files = [];
@@ -209,10 +213,6 @@ export class PeerLibrary {
         } // end of block to remove
         return undefined; // empty result
     }
-    hasInLibrary(entry) {
-        var _a, _b;
-        return !((_a = this.libraryPackages) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.libraryPackages) === null || _b === void 0 ? void 0 : _b.includes(idl.getPackageName(entry)));
-    }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
             return new OptionConvertor(this, param, idl.maybeUnwrapOptionalType(type));
@@ -234,6 +234,7 @@ export class PeerLibrary {
                 case idl.IDLF32Type: return new NumericConvertor(param, type);
                 case idl.IDLF64Type: return new NumericConvertor(param, type);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
+                case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
                 case idl.IDLBufferType: return new BufferConvertor(param);
                 case idl.IDLBooleanType: return new BooleanConvertor(param);
@@ -242,7 +243,7 @@ export class PeerLibrary {
                 case idl.IDLUndefinedType: return new UndefinedConvertor(param);
                 case idl.IDLVoidType: return new VoidConvertor(param);
                 case idl.IDLUnknownType:
-                case idl.IDLAnyType: return new CustomTypeConvertor(param, "Any", false, "Object");
+                case idl.IDLAnyType: return new ObjectConvertor(param);
                 case idl.IDLDate: return new DateConvertor(param);
                 default: throw new Error(`Unconverted primitive ${idl.DebugUtils.debugPrintType(type)}`);
             }

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

@@ -0,0 +1,5 @@
+import { ReferenceResolver } from './ReferenceResolver';
+import { IDLType } from "../idl";
+export declare function isEnumType(type: IDLType, resolver: ReferenceResolver): boolean;
+export declare function isStringEnumType(type: IDLType, resolver: ReferenceResolver): boolean;
+//# sourceMappingURL=isEnumType.d.ts.map

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

@@ -0,0 +1,29 @@
+/*
+ * 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 { isReferenceType, isEnum, isStringEnum } from "../idl";
+export function isEnumType(type, resolver) {
+    return toEnum(type, resolver) != undefined;
+}
+export function isStringEnumType(type, resolver) {
+    const enumNode = toEnum(type, resolver);
+    return enumNode ? isStringEnum(enumNode) : false;
+}
+function toEnum(type, resolver) {
+    if (!isReferenceType(type))
+        return undefined;
+    const resolved = resolver.resolveTypeReference(type);
+    return resolved && isEnum(resolved) ? resolved : undefined;
+}
+//# sourceMappingURL=isEnumType.js.map

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

@@ -0,0 +1,10 @@
+import { ModuleConfiguration } from "../config";
+import * as idl from "../idl";
+export declare function isInModule(node: idl.IDLNode, module: ModuleConfiguration): boolean;
+export declare function isInModule(packageName: string, module: ModuleConfiguration): boolean;
+export declare function getModuleFor(node: idl.IDLNode): ModuleConfiguration;
+export declare function getModuleFor(packageName: string): ModuleConfiguration;
+export declare function currentModule(): ModuleConfiguration;
+export declare function isInCurrentModule(node: idl.IDLNode): boolean;
+export declare function isInCurrentModule(packageName: string): boolean;
+//# sourceMappingURL=modules.d.ts.map

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

@@ -0,0 +1,38 @@
+import { generatorConfiguration } from "../config";
+import * as idl from "../idl";
+export function isInModule(nodeOrPackage, module) {
+    if (typeof nodeOrPackage === 'object')
+        return isInModule(idl.getPackageName(nodeOrPackage), module);
+    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+}
+export function getModuleFor(nodeOrPackage) {
+    if (typeof nodeOrPackage === "object")
+        return getModuleFor(idl.getPackageName(nodeOrPackage));
+    const packageName = nodeOrPackage;
+    const config = generatorConfiguration();
+    const applicableModules = [...config.modules.values()].filter(module => isInModule(packageName, module));
+    if (applicableModules.length === 0) {
+        if (nodeOrPackage === '') {
+            console.error("WARNING: use current module for empty package");
+            return currentModule();
+        }
+        throw new Error(`Package ${packageName} is not listed in any module`);
+    }
+    if (applicableModules.length > 1)
+        throw new Error(`Package ${packageName} listed in ${applicableModules.length} packages: ${applicableModules.map(it => it.name).join(", ")}`);
+    return applicableModules[0];
+}
+export function currentModule() {
+    const conf = generatorConfiguration();
+    const result = conf.modules.get(conf.moduleName);
+    if (!result)
+        throw new Error(`Can not determine current module configuration ${conf.moduleName}`);
+    return result;
+}
+export function isInCurrentModule(nodeOrPackage) {
+    if (typeof nodeOrPackage === 'string')
+        return isInModule(nodeOrPackage, currentModule());
+    else
+        return isInModule(nodeOrPackage, currentModule());
+}
+//# sourceMappingURL=modules.js.map

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

@@ -67,6 +67,7 @@ export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclar
  */
 export declare function nameEnumValues(enumTarget: ts.EnumDeclaration): string[];
 export declare function groupBy<K, V>(values: V[], selector: (value: V) => K): Map<K, V[]>;
+export declare function groupByIndexed<K, V>(values: V[], selector: (value: V) => K): Map<K, [V, number][]>;
 export declare function removeExt(filename: string): string;
 export declare function warn(message: string): void;
 export declare function hashCodeFromString(value: string): number;

package/build/lib/src/util.js

@@ -569,6 +569,12 @@ export function groupBy(values, selector) {
     });
     return map;
 }
+export function groupByIndexed(values, selector) {
+    const map = new Map();
+    values.forEach((it, index) => getOrPut(map, selector(it), () => [])
+        .push([it, index]));
+    return map;
+}
 export function removeExt(filename) {
     return filename.replaceAll(path.extname(filename), '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {
@@ -34,7 +34,7 @@
   },
   "keywords": [],
   "dependencies": {
-    "@koalaui/interop": "1.5.9",
+    "@koalaui/interop": "1.5.12",
     "typescript": "4.9.5",
     "@types/node": "^18.0.0"
   },

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

@@ -1,2 +0,0 @@
-export declare function deepMergeConfig<T extends object>(defaults: T, custom: Partial<T>): T;
-//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -1,42 +0,0 @@
-/*
- * 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.
- */
-function isObject(i) {
-    if (typeof i !== 'object')
-        return false;
-    if (Array.isArray(i))
-        return false;
-    return true;
-}
-export function deepMergeConfig(defaults, custom) {
-    if (custom === undefined)
-        return defaults;
-    const result = Object.assign({}, defaults);
-    for (const key in custom) {
-        if (Object.prototype.hasOwnProperty.call(custom, key)) {
-            const defaultValue = result[key];
-            const customValue = custom[key];
-            if (isObject(defaultValue) && isObject(customValue)) {
-                Object.assign(result, { [key]: deepMergeConfig(defaultValue, customValue) });
-            }
-            else {
-                if (isObject(defaultValue))
-                    throw new Error("Replacing default object value with custom non-object");
-                Object.assign(result, { [key]: customValue });
-            }
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=configMerge.js.map

package/webidl2.js/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Robin Berjon
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.