@idlizer/core 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

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

@@ -0,0 +1,141 @@
+import { generatorConfiguration } from "../config";
+import { toIdlType } from "../from-idl/deserialize";
+import * as idl from "../idl";
+import { isBuilderClass } from "../peer-generation/BuilderClass";
+import { generateSyntheticIdlNodeName } from "../peer-generation/idl/common";
+import { isMaterialized } from "../peer-generation/isMaterialized";
+import { inplaceFQN } from "./FqnTransformer";
+export function inplaceGenerics(node, resolver, options) {
+    var _a;
+    const candidates = [];
+    idl.forEachChild(node, () => { }, (child) => {
+        if (idl.isReferenceType(child))
+            candidates.push(child);
+    });
+    if (idl.isReferenceType(node)) {
+        candidates.push(node);
+    }
+    options !== null && options !== void 0 ? options : (options = {});
+    (_a = options.ignore) !== null && _a !== void 0 ? _a : (options.ignore = []);
+    options.ignore.push(ignoreConfigRule, ignoreBuilderClassRule, createIgnoreMaterializedRule(resolver));
+    candidates.forEach(it => inplaceReferenceGenerics(it, resolver, options));
+}
+export function isInplacedGeneric(entry) {
+    return idl.hasExtAttribute(entry, idl.IDLExtendedAttributes.OriginalGenericName);
+}
+export function maybeRestoreGenerics(maybeTransformedGeneric, resolver) {
+    if (idl.isReferenceType(maybeTransformedGeneric)) {
+        const resolved = resolver.resolveTypeReference(maybeTransformedGeneric);
+        return resolved ? maybeRestoreGenerics(resolved, resolver) : undefined;
+    }
+    if (maybeTransformedGeneric && idl.hasExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName)) {
+        const originalName = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.OriginalGenericName);
+        const typeArgumentsAttribute = idl.getExtAttribute(maybeTransformedGeneric, idl.IDLExtendedAttributes.TypeArguments);
+        if (!typeArgumentsAttribute)
+            throw new Error(`Can not restore original generic type arguments for ${originalName}: no type arguments`);
+        const typeArguments = typeArgumentsAttribute.split(',').map(it => { var _a; return toIdlType((_a = maybeTransformedGeneric.fileName) !== null && _a !== void 0 ? _a : "", it); });
+        return idl.createReferenceType(originalName, typeArguments, {
+            extendedAttributes: [{
+                    name: idl.IDLExtendedAttributes.TypeArguments,
+                    value: typeArgumentsAttribute,
+                }]
+        });
+    }
+    return undefined;
+}
+function ignoreConfigRule(node) {
+    if (idl.isEntry(node))
+        return generatorConfiguration().ignoreGenerics.includes(idl.getFQName(node));
+    return false;
+}
+function ignoreBuilderClassRule(node) {
+    return idl.isInterface(node) && isBuilderClass(node);
+}
+function createIgnoreMaterializedRule(resolver) {
+    return (node) => idl.isInterface(node) && isMaterialized(node, resolver);
+}
+function monomorphisedEntryName(typedEntry, typeArguments) {
+    return typedEntry.name + "_" + typeArguments.map(generateSyntheticIdlNodeName).join("_");
+}
+function monomorphizeEntry(typedEntry, typeArguments) {
+    var _a, _b, _c, _d;
+    if (!idl.isTypedef(typedEntry) && !idl.isInterface(typedEntry) && !idl.isCallback(typedEntry))
+        throw new Error(`Can not monomorphize ${typedEntry.kind}`);
+    if (((_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.length) != typeArguments.length)
+        throw new Error(`Trying to monomorphize entry ${typedEntry.name} that accepts ${(_b = typedEntry.typeParameters) === null || _b === void 0 ? void 0 : _b.length} type parameters with ${typeArguments.length} type arguments`);
+    const monomorphizedEntry = idl.clone(typedEntry);
+    monomorphizedEntry.name = monomorphisedEntryName(typedEntry, typeArguments);
+    monomorphizedEntry.typeParameters = undefined;
+    const nameToType = new Map(typedEntry.typeParameters.map((name, index) => [name, typeArguments[index]]));
+    idl.updateEachChild(monomorphizedEntry, (node) => {
+        var _a;
+        if (idl.isTypeParameterType(node)) {
+            if (!nameToType.has(node.name))
+                throw new Error(`Can not name ${node.name} in type parameters of ${typedEntry.name}: available are ${(_a = typedEntry.typeParameters) === null || _a === void 0 ? void 0 : _a.join(", ")}`);
+            return idl.clone(nameToType.get(node.name));
+        }
+        return node;
+    });
+    monomorphizedEntry.extendedAttributes = (_d = (_c = monomorphizedEntry.extendedAttributes) === null || _c === void 0 ? void 0 : _c.filter(it => {
+        return it.name != idl.IDLExtendedAttributes.TypeParameters;
+    })) !== null && _d !== void 0 ? _d : [];
+    monomorphizedEntry.extendedAttributes.push({
+        name: idl.IDLExtendedAttributes.OriginalGenericName,
+        value: idl.getFQName(typedEntry),
+    }, {
+        name: idl.IDLExtendedAttributes.TypeArguments,
+        value: typeArguments.map(type => idl.printType(type)).join("|"),
+    });
+    return monomorphizedEntry;
+}
+function hasTypeParameterTypeChild(node) {
+    let result = false;
+    idl.forEachChild(node, (child) => {
+        if (idl.isTypeParameterType(child))
+            result = true;
+    });
+    return result;
+}
+function inplaceReferenceGenerics(ref, resolver, options) {
+    var _a, _b;
+    if (!((_a = ref.typeArguments) === null || _a === void 0 ? void 0 : _a.length) || hasTypeParameterTypeChild(ref)) {
+        return;
+    }
+    ref.typeArguments.forEach(it => inplaceFQN(it, resolver));
+    const resolved = resolver.resolveTypeReference(ref);
+    if (!resolved) {
+        throw new Error(`Can not resolve ${ref.name}`);
+    }
+    if (((_b = options === null || options === void 0 ? void 0 : options.ignore) === null || _b === void 0 ? void 0 : _b.some(it => it(ref) || it(resolved))) || generatorConfiguration().ignoreGenerics.includes(idl.getFQName(resolved))) {
+        return;
+    }
+    if (!idl.isTypedef(resolved) && !idl.isInterface(resolved) && !idl.isCallback(resolved)) {
+        throw new Error(`Unsupported generics target ${resolved.kind}`);
+    }
+    const inplacedRef = idl.createReferenceType(monomorphisedEntryName(resolved, ref.typeArguments));
+    if (!resolver.resolveTypeReference(inplacedRef)) {
+        const monomorphizedEntry = monomorphizeEntry(resolved, ref.typeArguments);
+        insertEntryNearTo(monomorphizedEntry, resolved);
+        inplaceGenerics(monomorphizedEntry, resolver);
+    }
+    ref.name = inplacedRef.name;
+    ref.typeArguments = undefined;
+}
+function insertEntryNearTo(entry, anchor) {
+    if (!anchor.parent) {
+        throw new Error(`Entry used as anchor has not parent`);
+    }
+    let parentEntries;
+    if (idl.isFile(anchor.parent)) {
+        parentEntries = anchor.parent.entries;
+    }
+    else if (idl.isNamespace(anchor.parent)) {
+        parentEntries = anchor.parent.members;
+    }
+    else {
+        throw new Error(`Can not insert entry, unknown parent kind ${anchor.parent.kind}`);
+    }
+    parentEntries.splice(parentEntries.indexOf(anchor), 0, entry);
+    idl.linkParentBack(anchor.parent);
+}
+//# sourceMappingURL=GenericTransformer.js.map

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

@@ -90,7 +90,10 @@ type StringProperties<T> = {
     [Property in keyof T as (T[Property] extends string ? Property : never)]: T[Property];
 };
 export declare function sorted<T, N extends keyof StringProperties<T>>(array: T[], key: ((value: T) => string) | N): T[];
-export declare function getExtractorName(target: idl.IDLInterface, language: Language, toPtr?: boolean): string;
-export declare function getExternalTypePackage(node: idl.IDLEntry): string | undefined;
+export declare function mapLibraryName(node: idl.IDLEntry, lang: Language, mapping?: Map<string, Map<string, string>>, prefix?: string): string;
+export declare function getExtractor(target: idl.IDLInterface, lang: Language, toPtr?: boolean): {
+    receiver?: string;
+    method: string;
+};
 export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -17,7 +17,8 @@ import * as fs from "fs";
 import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
-import { generatorConfiguration } from './config';
+import { isInExternalModule } from './peer-generation/modules';
+import { getInternalClassName, getInternalClassQualifiedName } from './peer-generation/Materialized';
 /** True if this is visible outside this file, false otherwise */
 export function isNodePublic(node) {
     return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Public) !== 0;
@@ -690,16 +691,29 @@ export function sorted(array, key) {
     return array.map(it => it)
         .sort((a, b) => comparator.compare(a[key], b[key]));
 }
-export function getExtractorName(target, language, toPtr = true) {
-    // TODO: Update for CJ
-    return toPtr ? `to${target.name}Ptr` : `from${target.name}Ptr`;
-}
-export function getExternalTypePackage(node) {
-    if (!idl.isInterface(node))
-        return undefined;
-    const pack = idl.getPackageName(node);
-    if (generatorConfiguration().externalPackages.includes(pack))
-        return `@${pack}`;
-    return generatorConfiguration().externalTypes.get(node.name);
+export function mapLibraryName(node, lang, mapping, prefix = "@") {
+    var _a, _b;
+    const packageName = idl.getPackageName(node);
+    return (_b = (_a = mapping === null || mapping === void 0 ? void 0 : mapping.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(lang.name)) !== null && _b !== void 0 ? _b : `${prefix}${packageName}`;
+}
+function getExtractorClass(target, toPtr = true) {
+    if (isInExternalModule(target)) {
+        const qualifiedName = idl.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=util.js.map

package/package.json

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

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

@@ -1,4 +0,0 @@
-import * as idl from '../idl';
-import { ReferenceResolver } from './ReferenceResolver';
-export declare function isExternalType(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
-//# sourceMappingURL=isExternalType.d.ts.map

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

@@ -1,15 +0,0 @@
-import * as idl from '../idl';
-import { generatorConfiguration } from '../config';
-export function isExternalType(declaration, resolver) {
-    // declarations outside of the generator input dirs
-    if (generatorConfiguration().externalTypes.get(declaration.name) != undefined)
-        return true;
-    // treat as external types only declarations with methods
-    if (declaration.methods.length == 0)
-        return false;
-    const pack = idl.getPackageName(declaration);
-    if (generatorConfiguration().externalPackages.includes(pack))
-        return true;
-    return false;
-}
-//# sourceMappingURL=isExternalType.js.map