@jsii/kernel 1.85.0 → 1.86.1

package/lib/link.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.link = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+/**
+ * If `node` is started with `--preserve-symlinks`, the module loaded will
+ * preserve symbolic links instead of resolving them, making it possible to
+ * symbolically link packages in place instead of fully copying them.
+ */
+const PRESERVE_SYMLINKS = process.execArgv.includes('--preserve-symlinks');
 /**
  * Creates directories containing hard links if possible, and falls back on
  * copy otherwise.
@@ -11,6 +17,11 @@ const path_1 = require("path");
  * @param destination is the new file or directory to create.
  */
 function link(existing, destination) {
+    if (PRESERVE_SYMLINKS) {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(destination), { recursive: true });
+        (0, fs_1.symlinkSync)(existing, destination);
+        return;
+    }
     const stat = (0, fs_1.statSync)(existing);
     if (!stat.isDirectory()) {
         try {

package/lib/objects.d.ts

@@ -6,8 +6,11 @@ import * as api from './api';
  * This will return something if the object was constructed from a JSII-enabled
  * class/constructor, or if a literal object was annotated with type
  * information.
+ *
+ * @param obj the object for which a jsii FQN is requested.
+ * @param isVisibleType a function that determines if a type is visible.
  */
-export declare function jsiiTypeFqn(obj: any): string | undefined;
+export declare function jsiiTypeFqn(obj: any, isVisibleType: (fqn: spec.FQN) => boolean): spec.FQN | undefined;
 /**
  * If this object was previously serialized under a given reference, return the same reference
  *
@@ -17,7 +20,7 @@ export declare function objectReference(obj: unknown): api.ObjRef | undefined;
 /**
  * Set the JSII FQN for classes produced by a given constructor
  */
-export declare function tagJsiiConstructor(constructor: any, fqn: string): void;
+export declare function tagJsiiConstructor(constructor: any, fqn: spec.FQN): void;
 /**
  * Table of JSII objects
  *
@@ -25,16 +28,14 @@ export declare function tagJsiiConstructor(constructor: any, fqn: string): void;
  * type.
  */
 export declare class ObjectTable {
-    private readonly resolveType;
-    private readonly objects;
-    private nextid;
-    constructor(resolveType: (fqn: string) => spec.Type);
+    #private;
+    constructor(resolveType: (fqn: spec.FQN) => spec.Type);
     /**
      * Register the given object with the given type
      *
      * Return the existing registration if available.
      */
-    registerObject(obj: unknown, fqn: string, interfaces?: string[]): api.ObjRef;
+    registerObject(obj: unknown, fqn: spec.FQN, interfaces?: spec.FQN[]): api.ObjRef;
     /**
      * Find the object and registered type for the given ObjRef
      */
@@ -44,12 +45,10 @@ export declare class ObjectTable {
      */
     deleteObject({ [api.TOKEN_REF]: objid }: api.ObjRef): void;
     get count(): number;
-    private makeId;
-    private removeRedundant;
 }
 export interface RegisteredObject {
     instance: any;
-    fqn: string;
-    interfaces?: string[];
+    fqn: spec.FQN;
+    interfaces?: spec.FQN[];
 }
 //# sourceMappingURL=objects.d.ts.map

package/lib/objects.js

@@ -1,4 +1,16 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ObjectTable_instances, _ObjectTable_resolveType, _ObjectTable_objects, _ObjectTable_nextid, _ObjectTable_makeId, _ObjectTable_removeRedundant, _InterfaceCollection_resolveType, _InterfaceCollection_interfaces;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectTable = exports.tagJsiiConstructor = exports.objectReference = exports.jsiiTypeFqn = void 0;
 const spec = require("@jsii/spec");
@@ -15,18 +27,42 @@ const OBJID_SYMBOL = Symbol.for('$__jsii__objid__$');
  */
 const IFACES_SYMBOL = Symbol.for('$__jsii__interfaces__$');
 /**
- * Symbol we use to tag constructors that are exported from a JSII module.
+ * Symbol under which jsii runtime type information is stored.
  */
-const JSII_TYPE_FQN_SYMBOL = Symbol('$__jsii__fqn__$');
+const JSII_RTTI_SYMBOL = Symbol.for('jsii.rtti');
+/**
+ * Cache for resolved associations between constructors and FQNs.
+ */
+const RESOLVED_TYPE_FQN = new WeakMap();
 /**
  * Get the JSII fqn for an object (if available)
  *
  * This will return something if the object was constructed from a JSII-enabled
  * class/constructor, or if a literal object was annotated with type
  * information.
+ *
+ * @param obj the object for which a jsii FQN is requested.
+ * @param isVisibleType a function that determines if a type is visible.
  */
-function jsiiTypeFqn(obj) {
-    return obj.constructor[JSII_TYPE_FQN_SYMBOL];
+function jsiiTypeFqn(obj, isVisibleType) {
+    var _a;
+    const ctor = obj.constructor;
+    // We've already resolved for this type, return the cached value.
+    if (RESOLVED_TYPE_FQN.has(ctor)) {
+        return RESOLVED_TYPE_FQN.get(ctor);
+    }
+    let curr = ctor;
+    while ((_a = curr[JSII_RTTI_SYMBOL]) === null || _a === void 0 ? void 0 : _a.fqn) {
+        if (isVisibleType(curr[JSII_RTTI_SYMBOL].fqn)) {
+            const fqn = curr[JSII_RTTI_SYMBOL].fqn;
+            tagJsiiConstructor(curr, fqn);
+            tagJsiiConstructor(ctor, fqn);
+            return fqn;
+        }
+        // Walk up the prototype chain...
+        curr = Object.getPrototypeOf(curr);
+    }
+    return undefined;
 }
 exports.jsiiTypeFqn = jsiiTypeFqn;
 /**
@@ -74,17 +110,13 @@ function tagObject(obj, objid, interfaces) {
  * Set the JSII FQN for classes produced by a given constructor
  */
 function tagJsiiConstructor(constructor, fqn) {
-    if (Object.prototype.hasOwnProperty.call(constructor, JSII_TYPE_FQN_SYMBOL)) {
-        return assert(constructor[JSII_TYPE_FQN_SYMBOL] === fqn, `Unable to register ${constructor.name} as ${fqn}: it is already registerd with FQN ${constructor[JSII_TYPE_FQN_SYMBOL]}`);
+    const existing = RESOLVED_TYPE_FQN.get(constructor);
+    if (existing != null) {
+        return assert.strictEqual(existing, fqn, `Unable to register ${constructor.name} as ${fqn}: it is already registerd with FQN ${existing}`);
     }
     // Mark this constructor as exported from a jsii module, so we know we
     // should be considering it's FQN as a valid exported type.
-    Object.defineProperty(constructor, JSII_TYPE_FQN_SYMBOL, {
-        configurable: false,
-        enumerable: false,
-        writable: false,
-        value: fqn,
-    });
+    RESOLVED_TYPE_FQN.set(constructor, fqn);
 }
 exports.tagJsiiConstructor = tagJsiiConstructor;
 /**
@@ -95,9 +127,11 @@ exports.tagJsiiConstructor = tagJsiiConstructor;
  */
 class ObjectTable {
     constructor(resolveType) {
-        this.resolveType = resolveType;
-        this.objects = new Map();
-        this.nextid = 10000;
+        _ObjectTable_instances.add(this);
+        _ObjectTable_resolveType.set(this, void 0);
+        _ObjectTable_objects.set(this, new Map());
+        _ObjectTable_nextid.set(this, 10000);
+        __classPrivateFieldSet(this, _ObjectTable_resolveType, resolveType, "f");
     }
     /**
      * Register the given object with the given type
@@ -121,17 +155,17 @@ class ObjectTable {
                 if (!Object.prototype.hasOwnProperty.call(obj, IFACES_SYMBOL)) {
                     console.error(`[jsii/kernel] WARNING: referenced object ${existingRef[api.TOKEN_REF]} does not have the ${String(IFACES_SYMBOL)} property!`);
                 }
-                this.objects.get(existingRef[api.TOKEN_REF]).interfaces =
+                __classPrivateFieldGet(this, _ObjectTable_objects, "f").get(existingRef[api.TOKEN_REF]).interfaces =
                     obj[IFACES_SYMBOL] =
                         existingRef[api.TOKEN_INTERFACES] =
                             interfaces =
-                                this.removeRedundant(Array.from(allIfaces), fqn);
+                                __classPrivateFieldGet(this, _ObjectTable_instances, "m", _ObjectTable_removeRedundant).call(this, Array.from(allIfaces), fqn);
             }
             return existingRef;
         }
-        interfaces = this.removeRedundant(interfaces, fqn);
-        const objid = this.makeId(fqn);
-        this.objects.set(objid, { instance: obj, fqn, interfaces });
+        interfaces = __classPrivateFieldGet(this, _ObjectTable_instances, "m", _ObjectTable_removeRedundant).call(this, interfaces, fqn);
+        const objid = __classPrivateFieldGet(this, _ObjectTable_instances, "m", _ObjectTable_makeId).call(this, fqn);
+        __classPrivateFieldGet(this, _ObjectTable_objects, "f").set(objid, { instance: obj, fqn, interfaces });
         tagObject(obj, objid, interfaces);
         return { [api.TOKEN_REF]: objid, [api.TOKEN_INTERFACES]: interfaces };
     }
@@ -144,7 +178,7 @@ class ObjectTable {
             throw new kernel_1.JsiiFault(`Malformed object reference: ${JSON.stringify(objref)}`);
         }
         const objid = objref[api.TOKEN_REF];
-        const obj = this.objects.get(objid);
+        const obj = __classPrivateFieldGet(this, _ObjectTable_objects, "f").get(objid);
         if (!obj) {
             throw new kernel_1.JsiiFault(`Object ${objid} not found`);
         }
@@ -172,40 +206,41 @@ class ObjectTable {
      * Delete the registration with the given objref
      */
     deleteObject({ [api.TOKEN_REF]: objid }) {
-        if (!this.objects.delete(objid)) {
+        if (!__classPrivateFieldGet(this, _ObjectTable_objects, "f").delete(objid)) {
             throw new kernel_1.JsiiFault(`Object ${objid} not found`);
         }
     }
     get count() {
-        return this.objects.size;
-    }
-    makeId(fqn) {
-        return `${fqn}@${this.nextid++}`;
-    }
-    removeRedundant(interfaces, fqn) {
-        if (!interfaces || interfaces.length === 0) {
-            return undefined;
-        }
-        const result = new Set(interfaces);
-        const builtIn = new InterfaceCollection(this.resolveType);
-        if (fqn !== serialization_1.EMPTY_OBJECT_FQN) {
-            builtIn.addFromClass(fqn);
-        }
-        interfaces.forEach(builtIn.addFromInterface.bind(builtIn));
-        for (const iface of builtIn) {
-            result.delete(iface);
-        }
-        return result.size > 0 ? Array.from(result).sort() : undefined;
+        return __classPrivateFieldGet(this, _ObjectTable_objects, "f").size;
     }
 }
 exports.ObjectTable = ObjectTable;
+_ObjectTable_resolveType = new WeakMap(), _ObjectTable_objects = new WeakMap(), _ObjectTable_nextid = new WeakMap(), _ObjectTable_instances = new WeakSet(), _ObjectTable_makeId = function _ObjectTable_makeId(fqn) {
+    var _a, _b;
+    return `${fqn}@${__classPrivateFieldSet(this, _ObjectTable_nextid, (_b = __classPrivateFieldGet(this, _ObjectTable_nextid, "f"), _a = _b++, _b), "f"), _a}`;
+}, _ObjectTable_removeRedundant = function _ObjectTable_removeRedundant(interfaces, fqn) {
+    if (!interfaces || interfaces.length === 0) {
+        return undefined;
+    }
+    const result = new Set(interfaces);
+    const builtIn = new InterfaceCollection(__classPrivateFieldGet(this, _ObjectTable_resolveType, "f"));
+    if (fqn !== serialization_1.EMPTY_OBJECT_FQN) {
+        builtIn.addFromClass(fqn);
+    }
+    interfaces.forEach(builtIn.addFromInterface.bind(builtIn));
+    for (const iface of builtIn) {
+        result.delete(iface);
+    }
+    return result.size > 0 ? Array.from(result).sort() : undefined;
+};
 class InterfaceCollection {
     constructor(resolveType) {
-        this.resolveType = resolveType;
-        this.interfaces = new Set();
+        _InterfaceCollection_resolveType.set(this, void 0);
+        _InterfaceCollection_interfaces.set(this, new Set());
+        __classPrivateFieldSet(this, _InterfaceCollection_resolveType, resolveType, "f");
     }
     addFromClass(fqn) {
-        const ti = this.resolveType(fqn);
+        const ti = __classPrivateFieldGet(this, _InterfaceCollection_resolveType, "f").call(this, fqn);
         if (!spec.isClassType(ti)) {
             throw new kernel_1.JsiiFault(`Expected a class, but received ${spec.describeTypeReference(ti)}`);
         }
@@ -214,16 +249,16 @@ class InterfaceCollection {
         }
         if (ti.interfaces) {
             for (const iface of ti.interfaces) {
-                if (this.interfaces.has(iface)) {
+                if (__classPrivateFieldGet(this, _InterfaceCollection_interfaces, "f").has(iface)) {
                     continue;
                 }
-                this.interfaces.add(iface);
+                __classPrivateFieldGet(this, _InterfaceCollection_interfaces, "f").add(iface);
                 this.addFromInterface(iface);
             }
         }
     }
     addFromInterface(fqn) {
-        const ti = this.resolveType(fqn);
+        const ti = __classPrivateFieldGet(this, _InterfaceCollection_resolveType, "f").call(this, fqn);
         if (!spec.isInterfaceType(ti)) {
             throw new kernel_1.JsiiFault(`Expected an interface, but received ${spec.describeTypeReference(ti)}`);
         }
@@ -231,15 +266,15 @@ class InterfaceCollection {
             return;
         }
         for (const iface of ti.interfaces) {
-            if (this.interfaces.has(iface)) {
+            if (__classPrivateFieldGet(this, _InterfaceCollection_interfaces, "f").has(iface)) {
                 continue;
             }
-            this.interfaces.add(iface);
+            __classPrivateFieldGet(this, _InterfaceCollection_interfaces, "f").add(iface);
             this.addFromInterface(iface);
         }
     }
-    [Symbol.iterator]() {
-        return this.interfaces[Symbol.iterator]();
+    [(_InterfaceCollection_resolveType = new WeakMap(), _InterfaceCollection_interfaces = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _InterfaceCollection_interfaces, "f")[Symbol.iterator]();
     }
 }
 //# sourceMappingURL=objects.js.map

package/lib/serialization.d.ts

@@ -63,12 +63,15 @@ export declare const enum SerializationClass {
     ReferenceType = "RefType",
     Any = "Any"
 }
-declare type TypeLookup = (fqn: spec.FQN) => spec.Type;
+declare type FindSymbol = (fqn: spec.FQN) => any;
+declare type IsVisibleType = (fqn: spec.FQN) => boolean;
+declare type LookupType = (fqn: spec.FQN) => spec.Type;
 export interface SerializerHost {
     readonly objects: ObjectTable;
     debug(...args: any[]): void;
-    lookupType(fqn: string): spec.Type;
-    findSymbol(fqn: spec.FQN): any;
+    isVisibleType: IsVisibleType;
+    lookupType: LookupType;
+    findSymbol: FindSymbol;
 }
 interface Serializer {
     serialize(value: unknown, type: OptionalValueOrVoid, host: SerializerHost): any;
@@ -88,13 +91,15 @@ export interface TypeSerialization {
  *
  * There can be multiple, because the type can be a type union.
  */
-export declare function serializationType(typeRef: OptionalValueOrVoid, lookup: TypeLookup): TypeSerialization[];
+export declare function serializationType(typeRef: OptionalValueOrVoid, lookup: LookupType): TypeSerialization[];
 export declare function process(host: SerializerHost, serde: keyof Serializer, value: unknown, type: OptionalValueOrVoid, context: string): any;
 export declare class SerializationError extends Error {
     readonly value: unknown;
     readonly causes: readonly any[];
     readonly name: string;
-    constructor(message: string, value: unknown, causes?: readonly any[], { renderValue }?: {
+    constructor(message: string, value: unknown, { isVisibleType }: {
+        readonly isVisibleType: (fqn: string) => boolean;
+    }, causes?: readonly any[], { renderValue }?: {
         renderValue?: boolean;
     });
 }