init commit

node_modules/@jet/environment/dependencies/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object-graph"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@jet/environment/dependencies/jet-proxy.js

@@ -0,0 +1,106 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyProxyFactory = void 0;
+// LazyProxyFactory creates a Proxy which lazily loads its target once needed
+class LazyProxyFactory {
+    static makeProxy(name, lazyProvider) {
+        const target = new ProxyTarget(lazyProvider);
+        const handler = {
+            get: (_, property, __) => {
+                // Create the lazy dependency if needed
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    // The dependency unexpectedly couldn't be created, so we have nothing to proxy to
+                    return undefined;
+                }
+                // Get the property, which could be a function
+                const res = target.realObject[property];
+                // If it's a function, bind it to the real object
+                if (typeof res == "function") {
+                    return res.bind(target.realObject);
+                }
+                return res;
+            },
+            set: (_, property, value) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.set(target.realObject, property, value, target.realObject);
+            },
+            has: (_, property) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.has(target.realObject, property);
+            },
+            deleteProperty: (_, property) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.deleteProperty(target.realObject, property);
+            },
+            ownKeys: (_) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return [];
+                }
+                return Reflect.ownKeys(target.realObject);
+            },
+            getOwnPropertyDescriptor: (_, property) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return undefined;
+                }
+                return Reflect.getOwnPropertyDescriptor(target.realObject, property);
+            },
+            defineProperty: (_, property, descriptor) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.defineProperty(target.realObject, property, descriptor);
+            },
+            preventExtensions: (_) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                /* We need to prevent extensions on the actual proxy target
+                otherwise the Proxy throws a TypeError */
+                Reflect.preventExtensions(target);
+                return Reflect.preventExtensions(target.realObject);
+            },
+            isExtensible: (_) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.isExtensible(target.realObject);
+            },
+            getPrototypeOf: (_) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return null;
+                }
+                return Reflect.getPrototypeOf(target.realObject);
+            },
+            setPrototypeOf: (_, prototype) => {
+                if (target.createRealObjectIfNeeded(name) === undefined) {
+                    return false;
+                }
+                return Reflect.setPrototypeOf(target.realObject, prototype);
+            },
+        };
+        const res = new Proxy(target, handler);
+        return res;
+    }
+}
+exports.LazyProxyFactory = LazyProxyFactory;
+/* The proxy target begins by holding nothing,
+and eventually holds the real proxy target once needed */
+class ProxyTarget {
+    constructor(lazyProvider) {
+        this.lazyProvider = lazyProvider;
+    }
+    createRealObjectIfNeeded(name) {
+        if (this.realObject === undefined) {
+            this.realObject = this.lazyProvider.lazyDependencyFor(name);
+        }
+        return this.realObject;
+    }
+}
+//# sourceMappingURL=jet-proxy.js.map

node_modules/@jet/environment/dependencies/object-graph.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = exports.ObjectGraph = void 0;
+const optional_1 = require("../types/optional");
+/* eslint-disable no-underscore-dangle */
+class ObjectGraph {
+    constructor(name) {
+        this._members = {};
+        this.name = name;
+    }
+    adding(type, member) {
+        const clone = this.clone();
+        clone._members[type.name] = member;
+        return clone;
+    }
+    removing(type) {
+        const clone = this.clone();
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete clone._members[type.name];
+        return clone;
+    }
+    optional(type) {
+        return this._members[type.name];
+    }
+    required(type) {
+        const member = this._members[type.name];
+        if ((0, optional_1.isNothing)(member)) {
+            // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
+            const candidates = Object.keys(this._members).sort().join(", ");
+            throw new Error(`No member with type ${type.name} found in ${this.name}. Candidates ${candidates}`);
+        }
+        return member;
+    }
+    clone() {
+        const ctor = this.constructor;
+        // eslint-disable-next-line new-cap
+        const clone = new ctor(this.name);
+        for (const [type, member] of Object.entries(this._members)) {
+            clone._members[type] = member;
+        }
+        return clone;
+    }
+}
+exports.ObjectGraph = ObjectGraph;
+function inject(type, objectGraph) {
+    return objectGraph.required(type);
+}
+exports.inject = inject;
+//# sourceMappingURL=object-graph.js.map