@graphcommerce/graphql-codegen-near-operation-file 2.102.1 → 2.103.1

package/dist/fragment-resolver.js

@@ -1,25 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFragmentRegistry = void 0;
-const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
-const graphql_1 = require("graphql");
-const utils_1 = require("./utils");
+var visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+var graphql_1 = require("graphql");
+var utils_1 = require("./utils");
 /**
  * Used by `buildFragmentResolver` to build a mapping of fragmentNames to paths, importNames, and
  * other useful info
  */
-function buildFragmentRegistry({ generateFilePath }, { documents, config }, schemaObject) {
-    const baseVisitor = new visitor_plugin_common_1.BaseVisitor(config, {
+function buildFragmentRegistry(_a, _b, schemaObject) {
+    var generateFilePath = _a.generateFilePath;
+    var documents = _b.documents, config = _b.config;
+    var baseVisitor = new visitor_plugin_common_1.BaseVisitor(config, {
         scalars: (0, visitor_plugin_common_1.buildScalarsFromConfig)(schemaObject, config),
         dedupeOperationSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.dedupeOperationSuffix, false),
         omitOperationSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.omitOperationSuffix, false),
         fragmentVariablePrefix: (0, visitor_plugin_common_1.getConfigValue)(config.fragmentVariablePrefix, ''),
         fragmentVariableSuffix: (0, visitor_plugin_common_1.getConfigValue)(config.fragmentVariableSuffix, 'FragmentDoc'),
     });
-    const getFragmentImports = (possbileTypes, name) => {
-        const fragmentImports = [];
+    var getFragmentImports = function (possbileTypes, name) {
+        var fragmentImports = [];
         fragmentImports.push({ name: baseVisitor.getFragmentVariableName(name), kind: 'document' });
-        const fragmentSuffix = baseVisitor.getFragmentSuffix(name);
+        var fragmentSuffix = baseVisitor.getFragmentSuffix(name);
         if (possbileTypes.length === 1) {
             fragmentImports.push({
                 name: baseVisitor.convertName(name, {
@@ -30,11 +32,11 @@ function buildFragmentRegistry({ generateFilePath }, { documents, config }, sche
             });
         }
         else if (possbileTypes.length !== 0) {
-            possbileTypes.forEach((typeName) => {
+            possbileTypes.forEach(function (typeName) {
                 fragmentImports.push({
                     name: baseVisitor.convertName(name, {
                         useTypesPrefix: true,
-                        suffix: `_${typeName}_${fragmentSuffix}`,
+                        suffix: "_" + typeName + "_" + fragmentSuffix,
                     }),
                     kind: 'type',
                 });
@@ -42,27 +44,28 @@ function buildFragmentRegistry({ generateFilePath }, { documents, config }, sche
         }
         return fragmentImports;
     };
-    const duplicateFragmentNames = [];
-    const registry = documents.reduce((prev, documentRecord) => {
+    var duplicateFragmentNames = [];
+    var registry = documents.reduce(function (prev, documentRecord) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const fragments = documentRecord.document.definitions.filter((d) => d.kind === graphql_1.Kind.FRAGMENT_DEFINITION);
+        var fragments = documentRecord.document.definitions.filter(function (d) { return d.kind === graphql_1.Kind.FRAGMENT_DEFINITION; });
         if (fragments.length > 0) {
-            for (const fragment of fragments) {
-                const schemaType = schemaObject.getType(fragment.typeCondition.name.value);
+            for (var _i = 0, fragments_1 = fragments; _i < fragments_1.length; _i++) {
+                var fragment = fragments_1[_i];
+                var schemaType = schemaObject.getType(fragment.typeCondition.name.value);
                 if (!schemaType) {
-                    throw new Error(`Fragment "${fragment.name.value}" is set on non-existing type "${fragment.typeCondition.name.value}"!`);
+                    throw new Error("Fragment \"" + fragment.name.value + "\" is set on non-existing type \"" + fragment.typeCondition.name.value + "\"!");
                 }
-                const possibleTypes = (0, visitor_plugin_common_1.getPossibleTypes)(schemaObject, schemaType);
+                var possibleTypes = (0, visitor_plugin_common_1.getPossibleTypes)(schemaObject, schemaType);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const filePath = generateFilePath(documentRecord.location);
-                const imports = getFragmentImports(possibleTypes.map((t) => t.name), fragment.name.value);
+                var filePath = generateFilePath(documentRecord.location);
+                var imports = getFragmentImports(possibleTypes.map(function (t) { return t.name; }), fragment.name.value);
                 if (prev[fragment.name.value] &&
                     (0, graphql_1.print)(fragment) !== (0, graphql_1.print)(prev[fragment.name.value].node)) {
                     duplicateFragmentNames.push(fragment.name.value);
                 }
                 prev[fragment.name.value] = {
-                    filePath,
-                    imports,
+                    filePath: filePath,
+                    imports: imports,
                     onType: fragment.typeCondition.name.value,
                     node: fragment,
                 };
@@ -71,24 +74,26 @@ function buildFragmentRegistry({ generateFilePath }, { documents, config }, sche
         return prev;
     }, {});
     if (duplicateFragmentNames.length) {
-        throw new Error(`Multiple fragments with the name(s) "${duplicateFragmentNames.join(', ')}" were found.`);
+        throw new Error("Multiple fragments with the name(s) \"" + duplicateFragmentNames.join(', ') + "\" were found.");
     }
     return registry;
 }
 exports.buildFragmentRegistry = buildFragmentRegistry;
 /** Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements` */
 function buildFragmentResolver(collectorOptions, presetOptions, schemaObject) {
-    const fragmentRegistry = buildFragmentRegistry(collectorOptions, presetOptions, schemaObject);
-    const { baseOutputDir } = presetOptions;
-    const { baseDir, typesImport } = collectorOptions;
+    var fragmentRegistry = buildFragmentRegistry(collectorOptions, presetOptions, schemaObject);
+    var baseOutputDir = presetOptions.baseOutputDir;
+    var baseDir = collectorOptions.baseDir, typesImport = collectorOptions.typesImport;
     function resolveFragments(generatedFilePath, documentFileContent) {
-        const fragmentsInUse = (0, utils_1.extractExternalFragmentsInUse)(documentFileContent, fragmentRegistry);
-        const externalFragments = [];
+        var _a;
+        var fragmentsInUse = (0, utils_1.extractExternalFragmentsInUse)(documentFileContent, fragmentRegistry);
+        var externalFragments = [];
         // fragment files to import names
-        const fragmentFileImports = {};
-        for (const fragmentName of Object.keys(fragmentsInUse)) {
-            const level = fragmentsInUse[fragmentName];
-            const fragmentDetails = fragmentRegistry[fragmentName];
+        var fragmentFileImports = {};
+        for (var _i = 0, _b = Object.keys(fragmentsInUse); _i < _b.length; _i++) {
+            var fragmentName = _b[_i];
+            var level = fragmentsInUse[fragmentName];
+            var fragmentDetails = fragmentRegistry[fragmentName];
             if (fragmentDetails) {
                 // add top level references to the import object
                 // we don't checkf or global namespace because the calling config can do so
@@ -97,11 +102,11 @@ function buildFragmentResolver(collectorOptions, presetOptions, schemaObject) {
                         fragmentFileImports[fragmentDetails.filePath] = fragmentDetails.imports;
                     }
                     else {
-                        fragmentFileImports[fragmentDetails.filePath].push(...fragmentDetails.imports);
+                        (_a = fragmentFileImports[fragmentDetails.filePath]).push.apply(_a, fragmentDetails.imports);
                     }
                 }
                 externalFragments.push({
-                    level,
+                    level: level,
                     isExternal: true,
                     name: fragmentName,
                     onType: fragmentDetails.onType,
@@ -110,20 +115,22 @@ function buildFragmentResolver(collectorOptions, presetOptions, schemaObject) {
             }
         }
         return {
-            externalFragments,
-            fragmentImports: Object.entries(fragmentFileImports).map(([fragmentsFilePath, identifiers]) => ({
-                baseDir,
-                baseOutputDir,
-                outputPath: generatedFilePath,
-                importSource: {
-                    path: fragmentsFilePath,
-                    identifiers,
-                },
-                typesImport,
-            })),
+            externalFragments: externalFragments,
+            fragmentImports: Object.entries(fragmentFileImports).map(function (_a) {
+                var fragmentsFilePath = _a[0], identifiers = _a[1];
+                return ({
+                    baseDir: baseDir,
+                    baseOutputDir: baseOutputDir,
+                    outputPath: generatedFilePath,
+                    importSource: {
+                        path: fragmentsFilePath,
+                        identifiers: identifiers,
+                    },
+                    typesImport: typesImport,
+                });
+            }),
         };
     }
     return resolveFragments;
 }
 exports.default = buildFragmentResolver;
-//# sourceMappingURL=fragment-resolver.js.map

package/dist/index.js

@@ -1,21 +1,52 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preset = exports.resolveDocumentImports = void 0;
-const path_1 = require("path");
-const add_1 = __importDefault(require("@graphql-codegen/add"));
-const graphql_1 = require("graphql");
-const injectable_1 = require("./injectable");
-const resolve_document_imports_1 = require("./resolve-document-imports");
+var path_1 = require("path");
+var add_1 = __importDefault(require("@graphql-codegen/add"));
+var graphql_1 = require("graphql");
+var injectable_1 = require("./injectable");
+var resolve_document_imports_1 = require("./resolve-document-imports");
 Object.defineProperty(exports, "resolveDocumentImports", { enumerable: true, get: function () { return resolve_document_imports_1.resolveDocumentImports; } });
-const utils_1 = require("./utils");
+var utils_1 = require("./utils");
 function isFragment(documentFile) {
-    let name = false;
+    var name = false;
     (0, graphql_1.visit)(documentFile.document, {
         enter: {
-            FragmentDefinition: () => {
+            FragmentDefinition: function () {
                 name = true;
             },
         },
@@ -26,82 +57,62 @@ function isDocument(documentFiles) {
     return !documentFiles.every(isFragment);
 }
 exports.preset = {
-    buildGeneratesSection: (options) => {
+    buildGeneratesSection: function (options) {
+        var _a, _b, _c, _d, _e, _f;
         if (options.presetConfig.injectables) {
             options.documents = (0, injectable_1.injectInjectables)(options.documents);
         }
-        const schemaObject = options.schemaAst ?? (0, graphql_1.buildASTSchema)(options.schema, options.config);
-        const baseDir = options.presetConfig.cwd ?? process.cwd();
-        const extension = options.presetConfig.extension ?? '.generated.ts';
-        const folder = options.presetConfig.folder ?? '';
-        const importTypesNamespace = options.presetConfig.importTypesNamespace ?? 'Types';
-        const { importAllFragmentsFrom } = options.presetConfig;
-        const { baseTypesPath } = options.presetConfig;
+        var schemaObject = (_a = options.schemaAst) !== null && _a !== void 0 ? _a : (0, graphql_1.buildASTSchema)(options.schema, options.config);
+        var baseDir = (_b = options.presetConfig.cwd) !== null && _b !== void 0 ? _b : process.cwd();
+        var extension = (_c = options.presetConfig.extension) !== null && _c !== void 0 ? _c : '.generated.ts';
+        var folder = (_d = options.presetConfig.folder) !== null && _d !== void 0 ? _d : '';
+        var importTypesNamespace = (_e = options.presetConfig.importTypesNamespace) !== null && _e !== void 0 ? _e : 'Types';
+        var importAllFragmentsFrom = options.presetConfig.importAllFragmentsFrom;
+        var baseTypesPath = options.presetConfig.baseTypesPath;
         if (!baseTypesPath) {
-            throw new Error(`Preset "near-operation-file" requires you to specify "baseTypesPath" configuration and point it to your base types file (generated by "typescript" plugin)!`);
+            throw new Error("Preset \"near-operation-file\" requires you to specify \"baseTypesPath\" configuration and point it to your base types file (generated by \"typescript\" plugin)!");
         }
-        const shouldAbsolute = !baseTypesPath.startsWith('~');
-        const pluginMap = {
-            ...options.pluginMap,
-            add: add_1.default,
-        };
-        const sources = (0, resolve_document_imports_1.resolveDocumentImports)(options, schemaObject, {
-            baseDir,
-            generateFilePath(location) {
-                const newFilePath = (0, utils_1.defineFilepathSubfolder)(location, folder);
+        var shouldAbsolute = !baseTypesPath.startsWith('~');
+        var pluginMap = __assign(__assign({}, options.pluginMap), { add: add_1.default });
+        var sources = (0, resolve_document_imports_1.resolveDocumentImports)(options, schemaObject, {
+            baseDir: baseDir,
+            generateFilePath: function (location) {
+                var newFilePath = (0, utils_1.defineFilepathSubfolder)(location, folder);
                 return (0, utils_1.appendExtensionToFilePath)(newFilePath, extension);
             },
             schemaTypesSource: {
                 path: shouldAbsolute ? (0, path_1.join)(options.baseOutputDir, baseTypesPath) : baseTypesPath,
                 namespace: importTypesNamespace,
             },
-            typesImport: options.config.useTypeImports ?? false,
+            typesImport: (_f = options.config.useTypeImports) !== null && _f !== void 0 ? _f : false,
         });
-        return sources.map(({ importStatements, externalFragments, fragmentImports, documents, ...source }) => {
-            let fragmentImportsArr = fragmentImports;
+        return sources.map(function (_a) {
+            var importStatements = _a.importStatements, externalFragments = _a.externalFragments, fragmentImports = _a.fragmentImports, documents = _a.documents, source = __rest(_a, ["importStatements", "externalFragments", "fragmentImports", "documents"]);
+            var fragmentImportsArr = fragmentImports;
             if (importAllFragmentsFrom) {
-                fragmentImportsArr = fragmentImports.map((t) => {
-                    const newImportSource = typeof importAllFragmentsFrom === 'string'
-                        ? { ...t.importSource, path: importAllFragmentsFrom }
-                        : importAllFragmentsFrom(t.importSource, source.filename);
-                    return {
-                        ...t,
-                        importSource: newImportSource || t.importSource,
-                    };
+                fragmentImportsArr = fragmentImports.map(function (t) {
+                    var newImportSource = typeof importAllFragmentsFrom === 'string'
+                        ? __assign(__assign({}, t.importSource), { path: importAllFragmentsFrom }) : importAllFragmentsFrom(t.importSource, source.filename);
+                    return __assign(__assign({}, t), { importSource: newImportSource || t.importSource });
                 });
             }
-            const isDoc = isDocument(documents);
-            const isRelayOptimizer = !!Object.keys(pluginMap).find((plugin) => plugin.includes('relay-optimizer-plugin'));
-            const plugins = [
-                // TODO/NOTE I made globalNamespace include schema types - is that correct?
-                ...(options.config.globalNamespace
-                    ? []
-                    : importStatements.map((importStatement) => ({ add: { content: importStatement } }))),
-                ...options.plugins.filter((pluginOptions) => !isRelayOptimizer ||
+            var isDoc = isDocument(documents);
+            var isRelayOptimizer = !!Object.keys(pluginMap).find(function (plugin) {
+                return plugin.includes('relay-optimizer-plugin');
+            });
+            var plugins = __spreadArray(__spreadArray([], (options.config.globalNamespace
+                ? []
+                : importStatements.map(function (importStatement) { return ({ add: { content: importStatement } }); })), true), options.plugins.filter(function (pluginOptions) {
+                return !isRelayOptimizer ||
                     isDoc ||
-                    !Object.keys(pluginOptions).includes('typed-document-node')),
-            ];
-            const config = {
-                ...options.config,
+                    !Object.keys(pluginOptions).includes('typed-document-node');
+            }), true);
+            var config = __assign(__assign({}, options.config), { 
                 // This is set here in order to make sure the fragment spreads sub types
                 // are exported from operations file
-                exportFragmentSpreadSubTypes: true,
-                namespacedImportName: importTypesNamespace,
-                externalFragments,
-                fragmentImports: fragmentImportsArr,
-            };
-            return {
-                ...source,
-                documents,
-                plugins,
-                pluginMap,
-                config,
-                schema: options.schema,
-                schemaAst: schemaObject,
-                skipDocumentsValidation: true,
-            };
+                exportFragmentSpreadSubTypes: true, namespacedImportName: importTypesNamespace, externalFragments: externalFragments, fragmentImports: fragmentImportsArr });
+            return __assign(__assign({}, source), { documents: documents, plugins: plugins, pluginMap: pluginMap, config: config, schema: options.schema, schemaAst: schemaObject, skipDocumentsValidation: true });
         });
     },
 };
 exports.default = exports.preset;
-//# sourceMappingURL=index.js.map

package/dist/injectable.js

@@ -1,20 +1,29 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectInjectables = void 0;
-const graphql_1 = require("graphql");
+var graphql_1 = require("graphql");
 function isFragment(document) {
-    let is = false;
+    var is = false;
     (0, graphql_1.visit)(document, {
-        FragmentDefinition: () => {
+        FragmentDefinition: function () {
             is = true;
         },
     });
     return is;
 }
 function hasInjectableDirective(document) {
-    let is = false;
+    var is = false;
     (0, graphql_1.visit)(document, {
-        Directive: (node) => {
+        Directive: function (node) {
             if (!is && node.name.value === 'injectable')
                 is = true;
         },
@@ -22,9 +31,9 @@ function hasInjectableDirective(document) {
     return is && isFragment;
 }
 function hasInjectDirective(document) {
-    let is = false;
+    var is = false;
     (0, graphql_1.visit)(document, {
-        Directive: (node) => {
+        Directive: function (node) {
             if (!is && node.name.value === 'inject')
                 is = true;
         },
@@ -32,33 +41,34 @@ function hasInjectDirective(document) {
     return is && isFragment;
 }
 function throwInjectError(conf, message) {
-    const val = conf.into?.map((v) => `"${v}"`);
-    throw Error(`${message}
-  fragment ${conf.fragment?.name.value} on ${conf.fragment?.typeCondition.name.value} @inject(into: [${val}]) { ... }`);
+    var _a, _b, _c;
+    var val = (_a = conf.into) === null || _a === void 0 ? void 0 : _a.map(function (v) { return "\"" + v + "\""; });
+    throw Error(message + "\n  fragment " + ((_b = conf.fragment) === null || _b === void 0 ? void 0 : _b.name.value) + " on " + ((_c = conf.fragment) === null || _c === void 0 ? void 0 : _c.typeCondition.name.value) + " @inject(into: [" + val + "]) { ... }");
 }
 function assertValidInject(injectVal) {
-    const { into, fragment } = injectVal;
-    if (!fragment || into?.length === 0)
+    var into = injectVal.into, fragment = injectVal.fragment;
+    if (!fragment || (into === null || into === void 0 ? void 0 : into.length) === 0)
         throwInjectError(injectVal, 'Invalid inject');
 }
 function getInjectConf(document) {
     if (!hasInjectDirective(document))
         throw Error('');
-    const conf = { into: [] };
+    var conf = { into: [] };
     (0, graphql_1.visit)(document, {
-        Directive: (node) => {
+        Directive: function (node) {
             if (node.name.value !== 'inject')
                 return false;
             (0, graphql_1.visit)(node, {
-                Argument: (arg) => {
+                Argument: function (arg) {
                     if (arg.name.value !== 'into')
                         return false;
                     (0, graphql_1.visit)(arg, {
-                        ListValue: (list) => {
-                            list.values.forEach((value) => {
+                        ListValue: function (list) {
+                            list.values.forEach(function (value) {
                                 (0, graphql_1.visit)(value, {
-                                    StringValue: (string) => {
-                                        conf.into?.push(string.value);
+                                    StringValue: function (string) {
+                                        var _a;
+                                        (_a = conf.into) === null || _a === void 0 ? void 0 : _a.push(string.value);
                                     },
                                 });
                             });
@@ -69,7 +79,7 @@ function getInjectConf(document) {
             });
             return null;
         },
-        FragmentDefinition: (node) => {
+        FragmentDefinition: function (node) {
             conf.fragment = node;
         },
     });
@@ -77,36 +87,38 @@ function getInjectConf(document) {
     return conf;
 }
 function injectInjectable(injectables, injector) {
-    const injectVal = getInjectConf(injector);
-    const { into, fragment } = injectVal;
-    into.forEach((target) => {
-        let found = false;
-        injectables.forEach((injectable) => {
+    var injectVal = getInjectConf(injector);
+    var into = injectVal.into, fragment = injectVal.fragment;
+    into.forEach(function (target) {
+        var found = false;
+        injectables.forEach(function (injectable) {
             (0, graphql_1.visit)(injectable, {
-                FragmentDefinition: (frag) => {
+                FragmentDefinition: function (frag) {
                     if (frag.name.value === target) {
                         found = true;
-                        const spread = {
+                        var spread = {
                             kind: 'FragmentSpread',
                             name: { kind: 'Name', value: fragment.name.value },
                         };
-                        frag.selectionSet.selections = [...frag.selectionSet.selections, spread];
+                        frag.selectionSet.selections = __spreadArray(__spreadArray([], frag.selectionSet.selections, true), [spread], false);
                     }
                 },
             });
         });
         if (!found)
-            throwInjectError(injectVal, `fragment ${target} @injectable { ... } can not be found or isn't injectable`);
+            throwInjectError(injectVal, "fragment " + target + " @injectable { ... } can not be found or isn't injectable");
     });
 }
 function injectInjectables(documentFiles) {
-    const documents = documentFiles
-        .map(({ document }) => document)
-        .filter((doc) => doc);
-    const injectables = documents.filter((d) => isFragment(d) && hasInjectableDirective(d));
-    const injectors = documents.filter((d) => isFragment(d) && hasInjectDirective(d));
-    injectors.forEach((d) => injectInjectable(injectables, d));
+    var documents = documentFiles
+        .map(function (_a) {
+        var document = _a.document;
+        return document;
+    })
+        .filter(function (doc) { return doc; });
+    var injectables = documents.filter(function (d) { return isFragment(d) && hasInjectableDirective(d); });
+    var injectors = documents.filter(function (d) { return isFragment(d) && hasInjectDirective(d); });
+    injectors.forEach(function (d) { return injectInjectable(injectables, d); });
     return documentFiles;
 }
 exports.injectInjectables = injectInjectables;
-//# sourceMappingURL=injectable.js.map