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

package/build/lib/src/peer-generation/idl/common.js

@@ -54,11 +54,9 @@ export function collapseTypes(types, name) {
     });
     return uniqueTypes.length === 1 ? uniqueTypes[0] : idl.createUnionType(uniqueTypes, name);
 }
-export function generifiedTypeName(refType, refName) {
+export function generifiedTypeName(refType, nameConvertor, refName) {
     var _a;
-    if (!refType)
-        return undefined;
-    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it) /* FIXME: BUG! */).join(",");
+    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => nameConvertor.convert(it)).join(",");
     return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
 }
 export function sanitizeGenerics(genericDeclarationString) {
@@ -81,9 +79,11 @@ export function generateSyntheticFunctionParameterName(parameter) {
     }
     return generateSyntheticIdlNodeName(parameter.type);
 }
-export function generateSyntheticFunctionName(parameters, returnType, isAsync = false) {
-    let prefix = isAsync ? "AsyncCallback" : "Callback";
-    const names = parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
+export function generateSyntheticFunctionName(parameters, returnType, options) {
+    let prefix = (options === null || options === void 0 ? void 0 : options.isAsync) ? "AsyncCallback" : "Callback";
+    const names = (options === null || options === void 0 ? void 0 : options.nameConvertor) !== undefined
+        ? parameters.map(it => options.nameConvertor.convert(it.type)).concat(options.nameConvertor.convert(returnType))
+        : parameters.map(generateSyntheticFunctionParameterName).concat(generateSyntheticIdlNodeName(returnType));
     return `${prefix}_${names.join("_").replaceAll(".", "_")}`;
 }
 export function isImportAttr(decl) {

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

@@ -14,18 +14,17 @@
  */
 import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
-import { isBuilderClass } from './BuilderClass';
 import { getSuper } from './getSuperType';
 export function isMaterialized(declaration, resolver) {
     var _a;
     if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
         return false;
-    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
+    if (idl.isHandwritten(declaration))
         return false;
     if (generatorConfiguration().forceResource.includes(declaration.name)) {
         return false;
     }
-    if (generatorConfiguration().forceMaterialized.some(r => r === idl.getFQName(declaration))) {
+    if (generatorConfiguration().forceMaterialized.some(r => r === idl.getFQNameSafe(declaration))) {
         return true;
     }
     // TODO: rework this

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

@@ -51,6 +51,8 @@ function getApplicableModuleFor(packageName) {
         if (packageName.startsWith(`idlize.`)) {
             return currentModule();
         }
+        if (packageName === `synthetic`)
+            return currentModule();
         const modules = [...config.modules.keys()].map(it => `"${it}"`).join(", ");
         throw new Error(`Package "${packageName}" is not listed in any module.`
             + ` Add the "${packageName}" to the existed list of modules [${modules}] or new one in the configuration file`);

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

@@ -0,0 +1,4 @@
+import { ReferenceResolver } from "./ReferenceResolver";
+import * as idl from "../idl";
+export declare function toDeclaration(type: idl.IDLType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLEntry | idl.IDLType;
+//# sourceMappingURL=toDeclaration.d.ts.map

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

@@ -0,0 +1,53 @@
+import * as idl from "../idl";
+import { ArkCustomObject, ArkDate, ArkFunction, forceTypedefAsResource } from "./PeerLibrary";
+import { warn } from "../util";
+import { toIdlType } from "../from-idl/deserialize";
+import { isImportAttr } from "./idl/common";
+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=toDeclaration.js.map

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

@@ -22,7 +22,7 @@ export declare class UnionRuntimeTypeChecker {
     private duplicateMembers;
     constructor(convertors: ArgConvertor[]);
     private checkConflicts;
-    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
+    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter, library: LibraryInterface, type?: IDLType): LanguageExpression;
 }
 export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
 //# sourceMappingURL=unions.d.ts.map

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

@@ -12,6 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as idl from '../idl';
 import { convertType } from "../LanguageWriters";
 import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
 import { collapseTypes } from "./idl/common";
@@ -84,14 +85,21 @@ export class UnionRuntimeTypeChecker {
             }
         });
     }
-    makeDiscriminator(value, convertorIndex, writer) {
-        const convertor = this.convertors[convertorIndex];
-        if (this.conflictingConvertors.has(convertor) && writer.language === Language.TS) {
-            const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
-            if (discriminator)
-                return discriminator;
+    makeDiscriminator(value, convertorIndex, writer, library, type) {
+        let convertor = this.convertors[convertorIndex];
+        if (writer.language === Language.TS) {
+            const isArray = idl.IDLContainerUtils.isSequence(convertor.idlType);
+            if (isArray || this.conflictingConvertors.has(convertor)) {
+                // Check elements inside array
+                if (type && convertor.idlType != type) {
+                    convertor = library.typeConvertor("", type);
+                }
+                const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
+                if (discriminator)
+                    return discriminator;
+            }
         }
-        return writer.makeString(writer.discriminate(value, convertorIndex, convertor.idlType, convertor.runtimeTypes));
+        return writer.makeString(writer.discriminate(value, convertorIndex, type !== null && type !== void 0 ? type : convertor.idlType, convertor.runtimeTypes));
     }
 }
 export function flattenUnionType(library, type) {

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

@@ -1,3 +1,4 @@
 import { IDLFile, IDLNode, IDLNamedNode } from "./idl";
+export declare function getPov(node: IDLNode): IDLNode | undefined;
 export declare function resolveNamedNode(target: string[], pov: IDLNode | undefined, corpus: IDLFile[]): IDLNamedNode | undefined;
 //# sourceMappingURL=resolveNamedNode.d.ts.map

package/build/lib/src/resolveNamedNode.js

@@ -14,6 +14,13 @@
  */
 import { isReferenceType, hasExtAttribute, IDLExtendedAttributes } from "./idl";
 import { isFile, isNamedNode, isNamespace, isEnum, isInterface, isImport } from "./idl";
+export function getPov(node) {
+    let result = node;
+    while (result && !(isFile(result) || isNamespace(result))) {
+        result = result.parent;
+    }
+    return result;
+}
 export function resolveNamedNode(target, pov, corpus) {
     let result;
     let povScope = [];

package/build/lib/src/transformers/FqnTransformer.d.ts

@@ -1,4 +1,4 @@
 import * as idl from "../idl";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
-export declare function inplaceFQN(node: idl.IDLNode, resolver: ReferenceResolver): void;
+export declare function fqnTransformer(corpus: idl.IDLFile[], resolver: ReferenceResolver): idl.IDLFile[];
 //# sourceMappingURL=FqnTransformer.d.ts.map

package/build/lib/src/transformers/FqnTransformer.js

@@ -1,17 +1,25 @@
 import * as idl from "../idl";
-export function inplaceFQN(node, resolver) {
-    if (idl.isReferenceType(node))
-        inplaceReferenceFQN(node, resolver);
-    idl.forEachChild(node, (child) => {
-        if (idl.isReferenceType(child))
-            inplaceReferenceFQN(child, resolver);
-    });
+import { IdlTransformer } from "./IdlTransformer";
+export function fqnTransformer(corpus, resolver) {
+    const transformer = new FqnTransformer(resolver);
+    return corpus.map(file => transformer.visit(file)).map(idl.linkParentBack);
 }
-function inplaceReferenceFQN(ref, resolver) {
-    const resolved = resolver.resolveTypeReference(ref);
-    if (resolved === undefined) {
-        throw new Error("Can not expand FQN for " + ref.name);
+class FqnTransformer extends IdlTransformer {
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    visit(node) {
+        var _a;
+        if (idl.isReferenceType(node)) {
+            const resolved = this.resolver.resolveTypeReference(node);
+            if (resolved === undefined) {
+                this.resolver.resolveTypeReference(node);
+                throw new Error("Can not expand FQN for " + idl.DebugUtils.debugPrintType(node));
+            }
+            return idl.createReferenceType(idl.getFQName(resolved), (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.visit(it)), idl.cloneNodeInitializer(node));
+        }
+        return this.visitEachChild(node);
     }
-    ref.name = idl.getFQName(resolved);
 }
 //# sourceMappingURL=FqnTransformer.js.map

package/build/lib/src/transformers/GenericTransformer.d.ts

@@ -1,8 +1,9 @@
 import * as idl from "../idl";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
-export declare function inplaceGenerics(node: idl.IDLNode, resolver: ReferenceResolver, options?: {
-    ignore?: ((node: idl.IDLNode) => boolean)[];
-}): void;
+export declare function genericsTransformer(files: idl.IDLFile[], options: {
+    ignore: ((node: idl.IDLNode) => boolean)[];
+    ignoreGenerics: string[];
+}): idl.IDLFile[];
 export declare function isInplacedGeneric(entry: idl.IDLEntry): boolean;
 export declare function maybeRestoreGenerics(maybeTransformedGeneric: idl.IDLReferenceType | idl.IDLEntry, resolver: ReferenceResolver): idl.IDLReferenceType | undefined;
 //# sourceMappingURL=GenericTransformer.d.ts.map