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

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

@@ -45,6 +45,7 @@ export const IDLFunctionType = createPrimitiveType('Function');
 export const IDLCustomObjectType = createPrimitiveType('CustomObject');
 export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
 export const IDLNullTypeName = "idlize.stdlib.Null";
+export const IDLThrowsTypeName = "idlize.stdlib.Throws";
 export function isUndefinedType(type) {
     return isPrimitiveType(type) && type.name === IDLUndefinedType.name;
 }

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

@@ -1,6 +1,7 @@
 import { stringOrNone } from "../util";
 import { QNPattern } from "./discriminators";
 import { IDLNode, IDLNamedNode, IDLType, IDLEntry, IDLReferenceType, IDLContainerType, IDLSignature, IDLParameter, IDLEnum, IDLFile } from "./node";
+import { Language } from "../Language";
 export declare function entityToType(entity: IDLNode): IDLType;
 export declare function forceAsNamedNode(type: IDLNode): IDLNamedNode;
 export declare function isEqualByQualifedName(a?: IDLNamedNode, b?: IDLNamedNode, pattern?: QNPattern): boolean;
@@ -12,9 +13,6 @@ export declare function decomposeQualifiedName(type: IDLReferenceType): [string
 export declare function qualifiedNameStartsWith(node: IDLNode | string[], template: string[]): boolean;
 export declare function maybeUnwrapOptionalType(type: IDLType): IDLType;
 export declare function maybeOptional(type: IDLType, optional?: boolean): IDLType;
-export declare const DebugUtils: {
-    debugPrintType: (type: IDLType) => string;
-};
 export declare function asPromise(type?: IDLType): IDLContainerType | undefined;
 export declare function transformMethodsAsync2ReturnPromise(entry: IDLEntry): void;
 export declare function transformMethodsReturnPromise2Async(entry: IDLEntry): void;
@@ -41,4 +39,7 @@ export declare function hasTypeParameters(entry: IDLEntry): boolean;
 export declare function isGeneric(entry: IDLEntry): entry is IDLEntry & {
     typeParameters?: string[];
 };
+export declare function snakeToLowCamelNode(node: IDLEntry): string;
+export declare function entryToFunctionName(_language: Language, declaration: IDLEntry, prefix: string, postfix: string): string;
+export declare function isInNamespace(node: IDLEntry): boolean;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -12,11 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createOptionalType, createContainerType, createReferenceType } from "./builders";
-import { isNamedNode, getQualifiedName, getFQName, isOptionalType, isContainerType, IDLContainerUtils, isNamespace, isInPackage, isType, isEntry, isTypeParameterType, isInterface, isTypedef, isCallback, isMethod, isCallable, getExtAttribute, hasExtAttribute } from "./discriminators";
-import { printType } from "./dump";
+import { basename } from "node:path";
+import { capitalize } from "../util";
+import { createOptionalType, createContainerType, createReferenceType, IDLVoidType, IDLStringType } from "./builders";
+import { isNamedNode, getQualifiedName, getFQName, isOptionalType, isContainerType, IDLContainerUtils, isNamespace, isInPackage, isType, isEntry, isTypeParameterType, isInterface, isTypedef, isCallback, isMethod, isCallable, getExtAttribute, hasExtAttribute, getNamespacesPathFor } from "./discriminators";
 import { IDLKind, IDLExtendedAttributes } from "./node";
-import { IDLVoidType, IDLStringType } from "./stdlib";
 import { forEachChild, forEachFunction } from "./visitors";
 export function entityToType(entity) {
     if (isType(entity)) {
@@ -83,15 +83,6 @@ export function maybeOptional(type, optional = false) {
     }
     return type;
 }
-export const DebugUtils = {
-    debugPrintType: (type) => {
-        const filename = type.fileName ? `, fileName: '${type.fileName}'` : "";
-        if (isContainerType(type)) {
-            return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}', elements: [${type.elementType.map(DebugUtils.debugPrintType).join(', ')}]${filename}]`;
-        }
-        return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}'${filename}]`;
-    },
-};
 export function asPromise(type) {
     if (!type)
         return undefined;
@@ -212,4 +203,26 @@ export function isGeneric(entry) {
         || isMethod(entry)
         || isCallable(entry);
 }
+export function snakeToLowCamelNode(node) {
+    if (!node.fileName) {
+        throw new Error("Invalid Convert");
+    }
+    const classname = basename(node.fileName).replace(".idl", "").replace(".d.ts", "");
+    return classname
+        .split('_')
+        .filter(word => word !== '')
+        .map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+}
+export function entryToFunctionName(_language, declaration, prefix, postfix) {
+    return `${prefix}${getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}${postfix}`;
+}
+export function isInNamespace(node) {
+    return getNamespacesPathFor(node).length > 0;
+}
 //# sourceMappingURL=utils.js.map

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

@@ -12,8 +12,7 @@
  * 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 { createInterface, createFile, createNamespace, createMethod, createCallable, createCallback, createConstructor, createUnionType, createOptionalType, createConstant, createEnum, createEnumMember, createProperty, createParameter, createTypedef, createContainerType, createReferenceType, createImport, createTypeParameterReference, createVersion, generateSyntheticUnionName } 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) {
@@ -199,9 +198,10 @@ export function updateEachChild(node, op, cbLeave) {
     return node;
 }
 export function cloneNodeInitializer(other) {
+    var _a;
     return {
         documentation: other.documentation,
-        extendedAttributes: other.extendedAttributes,
+        extendedAttributes: (_a = other.extendedAttributes) === null || _a === void 0 ? void 0 : _a.map(it => { return Object.assign({}, it); }),
         fileName: other.fileName,
         nameLocation: other.nameLocation,
         nodeLocation: other.nodeLocation,
@@ -392,7 +392,7 @@ export function linkParentBack(node) {
     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;
+    var _a, _b, _c, _d;
     const make = (newnode) => {
         if (node.nodeLocation) {
             newnode.nodeLocation = node.nodeLocation;
@@ -409,51 +409,27 @@ export function clone(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
-            }));
+            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), cloneNodeInitializer(node)));
         }
         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
-            }));
+            return make(createImport(entry.clause, entry.name, cloneNodeInitializer(entry)));
         }
         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));
+            return make(createCallback(entry.name, entry.parameters.map(clone), clone(entry.returnType), cloneNodeInitializer(entry), 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
-            }));
+            return make(createConstant(entry.name, clone(entry.type), entry.value, cloneNodeInitializer(entry)));
         }
         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
-            }));
+            return make(createProperty(entry.name, clone(entry.type), entry.isReadonly, entry.isStatic, entry.isOptional, cloneNodeInitializer(entry)));
         }
         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
-            }));
+            return make(createParameter(entry.name, clone(entry.type), entry.isOptional, entry.isVariadic, cloneNodeInitializer(entry)));
         }
         case IDLKind.Method: {
             const entry = get(node);
@@ -462,38 +438,22 @@ export function clone(node) {
                 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));
+            }, cloneNodeInitializer(entry), 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));
+            }, cloneNodeInitializer(entry), 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
-            }));
+            return make(createConstructor(entry.parameters.map(clone), entry.returnType ? clone(entry.returnType) : undefined, cloneNodeInitializer(entry)));
         }
         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
-            });
+            const cloned = createEnum(entry.name, entry.elements.map(clone), cloneNodeInitializer(entry));
             cloned.elements.forEach(it => {
                 it.parent = cloned;
             });
@@ -501,86 +461,46 @@ export function clone(node) {
         }
         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
-            }));
+            return make(createEnumMember(entry.name, entry.parent, clone(entry.type), entry.initializer, cloneNodeInitializer(entry)));
         }
         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
-            }));
+            return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, cloneNodeInitializer(entry)));
         }
         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
-            }));
+            return make(createContainerType(type.containerKind, type.elementType.map(clone), cloneNodeInitializer(type)));
         }
         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
-            }));
+            return make(createReferenceType(type.name, (_d = type.typeArguments) === null || _d === void 0 ? void 0 : _d.map(clone), cloneNodeInitializer(type)));
         }
         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
-            }));
+            return make(createUnionType(type.types.map(clone), type.name, cloneNodeInitializer(type)));
         }
         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
-            }));
+            return make(createTypeParameterReference(type.name, cloneNodeInitializer(type)));
         }
         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
-            }));
+            return make(createOptionalType(clone(type.type), cloneNodeInitializer(type)));
         }
         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
-            }));
+            return make(createVersion(entry.value, cloneNodeInitializer(entry)));
         }
         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
-            }));
+            return make(createNamespace(ns.name, ns.members.map(clone), cloneNodeInitializer(ns)));
         }
         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
-            }));
+            return make(createFile(file.entries.map(clone), file.fileName, file.packageClause, cloneNodeInitializer(file)));
         }
     }
 }

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

@@ -46,12 +46,15 @@ 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 "./peer-generation/Extractors";
+export * from "./peer-generation/Initializers";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";
+export * from "./transformers/ThrowsTransformer";
 export * from "./transformers/OnSerializeTransformer";
 export * from "./transformers/IdlTransformer";
+export * from "./transformers/transformUtils";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

package/build/lib/src/index.js

@@ -60,12 +60,15 @@ 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 "./peer-generation/Extractors";
+export * from "./peer-generation/Initializers";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";
+export * from "./transformers/ThrowsTransformer";
 export * from "./transformers/OnSerializeTransformer";
 export * from "./transformers/IdlTransformer";
+export * from "./transformers/transformUtils";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

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

@@ -0,0 +1,7 @@
+import { IDLInterface } from "../idl";
+import { Language } from "../Language";
+export declare function getExtractor(target: IDLInterface, lang: Language, toPtr?: boolean): {
+    receiver?: string;
+    method: string;
+};
+//# sourceMappingURL=Extractors.d.ts.map

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

@@ -0,0 +1,40 @@
+/*
+ * 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 { getQualifiedName } from "../idl";
+import { Language } from "../Language";
+import { capitalize } from "../util";
+import { getInternalClassName, getInternalClassQualifiedName } from "./isMaterialized";
+import { isInExternalModule } from "./modules";
+function getExtractorClass(target, toPtr = true) {
+    if (isInExternalModule(target)) {
+        const qualifiedName = getQualifiedName(target, "namespace.name");
+        const name = qualifiedName.split(`.`).map(it => capitalize(it)).join("");
+        return name;
+    }
+    return toPtr ? "Peer" : "";
+}
+export function getExtractor(target, lang, toPtr = true) {
+    const receiver = isInExternalModule(target)
+        ? `extractors`
+        : toPtr
+            ? undefined // TBD: update to MaterializedBase when import is updated
+            : (lang == Language.CJ || lang == Language.KOTLIN)
+                ? getInternalClassName(target.name)
+                : getInternalClassQualifiedName(target, "namespace.name", lang);
+    const extractorClass = getExtractorClass(target, toPtr);
+    const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
+    return { receiver, method };
+}
+//# sourceMappingURL=Extractors.js.map

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

@@ -0,0 +1,5 @@
+import { IDLEntry } from "../idl";
+import { Language } from "../Language";
+export declare function getInitializerFeature(lang: Language): string;
+export declare function getInitializerDefaultValue(decl: IDLEntry, lang: Language): string;
+//# sourceMappingURL=Initializers.d.ts.map

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

@@ -0,0 +1,28 @@
+/*
+ * 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 { getFQName, isProperty } from "../idl";
+export function getInitializerFeature(lang) {
+    // TBD: update code for KT and CJ
+    return "initializers";
+}
+export function getInitializerDefaultValue(decl, lang) {
+    const parent = decl.parent;
+    const fqn = parent && isProperty(decl)
+        ? `${getFQName(parent)}NS.${decl.name}`
+        : getFQName(decl);
+    // TBD: update code for KT and CJ
+    return `${getInitializerFeature(lang)}.${fqn}`;
+}
+//# sourceMappingURL=Initializers.js.map

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

@@ -1,5 +1,4 @@
 import * as idl from '../idl';
-import { Language } from '../Language';
 import { ArgConvertor } from '../LanguageWriters/ArgConvertors';
 import { Field, Method } from '../LanguageWriters/LanguageWriter';
 import { PeerClassBase } from './PeerClass';
@@ -56,7 +55,4 @@ export declare class MaterializedClass implements PeerClassBase {
     isGlobalScope(): boolean;
 }
 export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod | undefined;
-export declare function getInternalClassName(name: string): string;
-export declare function getInternalClassQualifiedName(target: idl.IDLEntry, pattern?: idl.QNPattern, language?: Language): string;
-export declare function getMaterializedFileName(name: string): string;
 //# sourceMappingURL=Materialized.d.ts.map

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

@@ -13,9 +13,8 @@
  * limitations under the License.
  */
 import * as idl from '../idl';
-import { copyMethod, FieldModifier, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
-import { capitalize } from '../util';
-import { qualifiedName } from './idl/common';
+import { copyMethod, FieldModifier, Method, METHOD_ACCESS_MODIFIERS, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
+import { getInternalClassName } from './isMaterialized';
 import { PeerMethod, PeerMethodSignature } from './PeerMethod';
 export class MaterializedField {
     constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField, extraMethodName = undefined) {
@@ -63,18 +62,18 @@ export class MaterializedMethod extends PeerMethod {
     getPrivateMethod(asProtected = false) {
         var _a, _b;
         let privateMethod = this;
-        if (!((_a = privateMethod.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.PRIVATE))) {
-            privateMethod = copyMaterializedMethod(this, {
-                method: copyMethod(this.method, {
-                    modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
-                        .filter(it => it !== MethodModifier.PUBLIC)
-                        .filter(it => it !== MethodModifier.OVERRIDE)
-                        .filter(it => !asProtected || (it !== MethodModifier.PRIVATE))
-                        .concat([asProtected ? MethodModifier.PROTECTED : MethodModifier.PRIVATE])
-                })
-            });
+        const neededModifier = asProtected ? MethodModifier.PROTECTED : MethodModifier.PRIVATE;
+        if ((_a = privateMethod.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(neededModifier)) {
+            return privateMethod;
         }
-        return privateMethod;
+        return copyMaterializedMethod(this, {
+            method: copyMethod(this.method, {
+                modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
+                    .filter(it => !METHOD_ACCESS_MODIFIERS.has(it))
+                    .filter(it => it !== MethodModifier.OVERRIDE)
+                    .concat([neededModifier])
+            })
+        });
     }
     withReturnType(returnType) {
         const s = this.method.signature;
@@ -127,14 +126,4 @@ export function createDestroyPeerMethod(clazz) {
     }
     return new MaterializedMethod(undefined, new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, PeerMethodSignature.DESTROY, new Method(PeerMethodSignature.DESTROY, new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
-export function getInternalClassName(name) {
-    return `${name}Internal`;
-}
-export function getInternalClassQualifiedName(target, pattern = "package.namespace.name", language) {
-    return getInternalClassName(qualifiedName(target, language !== null && language !== void 0 ? language : ".", pattern));
-}
-export function getMaterializedFileName(name) {
-    const pascalCase = name.split('_').map(x => capitalize(x)).join('');
-    return `Ark${pascalCase}Materialized`;
-}
 //# sourceMappingURL=Materialized.js.map

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

@@ -10297,4 +10297,5 @@ export declare const ArkDate: idl.IDLPrimitiveType;
 export declare const ArkCustomObject: idl.IDLPrimitiveType;
 export declare function cleanPrefix(name: string, prefix: string): string;
 export declare function forceTypedefAsResource(resolver: ReferenceResolver, type: idl.IDLType, decl: idl.IDLTypedef): boolean;
+export declare function toDeclaration(type: idl.IDLType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLEntry | idl.IDLType;
 //# sourceMappingURL=PeerLibrary.d.ts.map

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, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, TransformOnSerializeConvertor, ThrowsConvertor, } from "../LanguageWriters/ArgConvertors";
 import { StructureNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -31,7 +31,7 @@ import { generatorConfiguration } from '../config';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
 import { toIdlType } from '../from-idl/deserialize';
 import { createCachedReferenceResolver } from './ReferenceResolver';
-import { toDeclaration } from './toDeclaration';
+import { maybeRestoreThrows } from '../transformers/transformUtils';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -248,8 +248,9 @@ export class PeerLibrary {
             throw new Error(`Unexpected declaration ${declaration.kind}`);
         }
         if (idl.hasExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize)) {
+            const sourceType = type;
             const targetType = toIdlType("", idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
-            return new TransformOnSerializeConvertor(param, this, declaration, targetType);
+            return new TransformOnSerializeConvertor(param, this, declaration, sourceType, targetType);
         }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
@@ -266,6 +267,9 @@ export class PeerLibrary {
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
+            if (maybeRestoreThrows(declaration, this)) {
+                return new ThrowsConvertor(this, param, declaration);
+            }
             if (generatorConfiguration().forceResource.includes(declaration.name)) {
                 return new ObjectConvertor(param, type);
             }
@@ -338,4 +342,51 @@ function isCyclicTypeDef(resolver, decl) {
     });
     return foundCycle;
 }
+export function toDeclaration(type, resolver) {
+    switch (type) {
+        case idl.IDLAnyType: return ArkCustomObject;
+        case idl.IDLVoidType: return idl.IDLVoidType;
+        case idl.IDLUndefinedType: return idl.IDLUndefinedType;
+        case idl.IDLUnknownType: return ArkCustomObject;
+        // case idl.IDLObjectType: return ArkCustomObject
+    }
+    const typeName = idl.isNamedNode(type) ? type.name : undefined;
+    switch (typeName) {
+        case "object":
+        case "Object": return idl.IDLObjectType;
+    }
+    if (idl.isReferenceType(type)) {
+        // TODO: remove all this!
+        if (type.name === 'Date') {
+            return ArkDate;
+        }
+        if (type.name === 'AnimationRange') {
+            return ArkCustomObject;
+        }
+        if (type.name === 'Function') {
+            return ArkFunction;
+        }
+        if (type.name === 'Optional') {
+            return toDeclaration(type.typeArguments[0], resolver);
+        }
+        const decl = resolver.resolveTypeReference(type);
+        if (!decl) {
+            warn(`undeclared type ${idl.DebugUtils.debugPrintType(type)}`);
+        }
+        if (decl && idl.isTypedef(decl) && forceTypedefAsResource(resolver, type, decl)) {
+            return idl.IDLObjectType;
+        }
+        if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
+            const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
+            return toDeclaration(type, resolver);
+        }
+        return !decl ? ArkCustomObject // assume some builtin type
+            : idl.isTypedef(decl) ? toDeclaration(decl.type, resolver)
+                : decl;
+    }
+    if (isImportAttr(type)) {
+        return ArkCustomObject;
+    }
+    return type;
+}
 //# sourceMappingURL=PeerLibrary.js.map

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

@@ -24,6 +24,7 @@ export declare class PeerMethodSignature {
     static mangleOverloadedName(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): OverloadInfo;
     static get CTOR(): string;
     static get GET_FINALIZER(): string;
+    static get CALL_HOLDER(): string;
     static get DESTROY(): string;
 }
 export declare class PeerMethod {

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

@@ -77,6 +77,7 @@ export class PeerMethodSignature {
     }
     static get CTOR() { return "construct"; }
     static get GET_FINALIZER() { return "getFinalizer"; }
+    static get CALL_HOLDER() { return "callHolder"; }
     static get DESTROY() { return "destroyPeer"; }
 }
 export class PeerMethod {

package/build/lib/src/peer-generation/idl/common.d.ts

@@ -1,12 +1,10 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
 import { IdlNameConvertor } from "../../LanguageWriters";
-export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
 export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string, pattern: idl.QNPattern): string;
 export declare function collapseTypes(types: idl.IDLType[], name?: string): idl.IDLType;
 export declare function generifiedTypeName(refType: idl.IDLReferenceType, nameConvertor: IdlNameConvertor, refName?: string): string;
 export declare function sanitizeGenerics(genericDeclarationString: string): string;
-export declare function generateSyntheticUnionName(types: idl.IDLType[]): string;
 export declare function generateSyntheticFunctionParameterName(parameter: idl.IDLParameter): string;
 export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, options?: {
     isAsync?: boolean;