@graphql-tools/webpack-loader 6.6.3 → 6.7.0-alpha-80e1b48b.0

package/cjs/index.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const os_1 = tslib_1.__importDefault(require("os"));
+const graphql_1 = require("graphql");
+const webpack_loader_runtime_1 = require("@graphql-tools/webpack-loader-runtime");
+const parser_js_1 = require("./parser.js");
+const optimize_1 = require("@graphql-tools/optimize");
+function isSDL(doc) {
+    return !doc.definitions.some(def => (0, graphql_1.isExecutableDefinitionNode)(def));
+}
+function expandImports(source, options) {
+    const lines = source.split(/\r\n|\r|\n/);
+    let outputCode = options.importHelpers
+        ? `
+    var useUnique = require('@graphql-tools/webpack-loader-runtime').useUnique;
+    var unique = useUnique();
+  `
+        : `
+    ${webpack_loader_runtime_1.uniqueCode}
+  `;
+    lines.some(line => {
+        if (line[0] === '#' && line.slice(1).split(' ')[0] === 'import') {
+            const importFile = line.slice(1).split(' ')[1];
+            const parseDocument = `require(${importFile})`;
+            const appendDef = `doc.definitions = doc.definitions.concat(unique(${parseDocument}.definitions));`;
+            outputCode += appendDef + os_1.default.EOL;
+        }
+        return line.length !== 0 && line[0] !== '#';
+    });
+    return outputCode;
+}
+function graphqlLoader(source) {
+    this.cacheable();
+    // TODO: This should probably use this.getOptions()
+    const options = this.query || {};
+    let doc = (0, parser_js_1.parseDocument)(source);
+    const optimizers = [];
+    if (options.noDescription) {
+        optimizers.push(optimize_1.removeDescriptions);
+    }
+    if (options.noEmptyNodes) {
+        optimizers.push(optimize_1.removeEmptyNodes);
+    }
+    if (optimizers.length > 0 && isSDL(doc)) {
+        doc = (0, optimize_1.optimizeDocumentNode)(doc, optimizers);
+    }
+    let stringifiedDoc = JSON.stringify(doc);
+    if (options.replaceKinds) {
+        for (const identifier in graphql_1.Kind) {
+            const value = graphql_1.Kind[identifier];
+            stringifiedDoc = stringifiedDoc.replace(new RegExp(`"kind":"${value}"`, 'g'), `"kind": Kind.${identifier}`);
+        }
+    }
+    const headerCode = `
+    ${options.replaceKinds ? "var Kind = require('graphql/language/kinds');" : ''}
+    var doc = ${stringifiedDoc};
+  `;
+    let outputCode = '';
+    // Allow multiple query/mutation definitions in a file. This parses out dependencies
+    // at compile time, and then uses those at load time to create minimal query documents
+    // We cannot do the latter at compile time due to how the #import code works.
+    const operationCount = doc.definitions.reduce((accum, op) => {
+        if (op.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+            return accum + 1;
+        }
+        return accum;
+    }, 0);
+    function exportDefaultStatement(identifier) {
+        if (options.esModule) {
+            return `export default ${identifier}`;
+        }
+        return `module.exports = ${identifier}`;
+    }
+    if (operationCount > 1) {
+        throw new Error('GraphQL Webpack Loader allows only for one GraphQL Operation per file');
+    }
+    outputCode += `
+    ${exportDefaultStatement('doc')}
+  `;
+    const importOutputCode = expandImports(source, options);
+    const allCode = [headerCode, importOutputCode, outputCode, ''].join(os_1.default.EOL);
+    return allCode;
+}
+exports.default = graphqlLoader;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/parser.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocument = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Strip insignificant whitespace
+ * Note that this could do a lot more, such as reorder fields etc.
+ */
+function normalize(str) {
+    return str.replace(/[\s,]+/g, ' ').trim();
+}
+// A map docString -> graphql document
+const docCache = {};
+// A map fragmentName -> [normalized source]
+const fragmentSourceMap = {};
+function cacheKeyFromFragment(fragment) {
+    return normalize((0, graphql_1.print)(fragment));
+}
+/**
+ * Take a unstripped parsed document (query/mutation or even fragment), and
+ * check all fragment definitions, checking for name->source uniqueness.
+ * We also want to make sure only unique fragments exist in the document.
+ */
+function processFragments(ast) {
+    const astFragmentMap = {};
+    const definitions = [];
+    for (let i = 0; i < ast.definitions.length; i++) {
+        const fragmentDefinition = ast.definitions[i];
+        if (fragmentDefinition.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+            const fragmentName = fragmentDefinition.name.value;
+            const sourceKey = cacheKeyFromFragment(fragmentDefinition);
+            // We know something about this fragment
+            if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {
+                fragmentSourceMap[fragmentName][sourceKey] = true;
+            }
+            else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {
+                fragmentSourceMap[fragmentName] = {};
+                fragmentSourceMap[fragmentName][sourceKey] = true;
+            }
+            if (!astFragmentMap[sourceKey]) {
+                astFragmentMap[sourceKey] = true;
+                definitions.push(fragmentDefinition);
+            }
+        }
+        else {
+            definitions.push(fragmentDefinition);
+        }
+    }
+    ast.definitions = definitions;
+    return ast;
+}
+function parseDocument(doc) {
+    const cacheKey = normalize(doc);
+    if (docCache[cacheKey]) {
+        return docCache[cacheKey];
+    }
+    const parsed = (0, graphql_1.parse)(doc, {
+        noLocation: true,
+    });
+    if (!parsed || parsed.kind !== 'Document') {
+        throw new Error('Not a valid GraphQL document.');
+    }
+    // check that all "new" fragments inside the documents are consistent with
+    // existing fragments of the same name
+    docCache[cacheKey] = processFragments(parsed);
+    return parsed;
+}
+exports.parseDocument = parseDocument;

package/{index.mjs → esm/index.js}

@@ -1,72 +1,8 @@
 import os from 'os';
-import { parse, Kind, print, isExecutableDefinitionNode } from 'graphql';
+import { isExecutableDefinitionNode, Kind } from 'graphql';
 import { uniqueCode } from '@graphql-tools/webpack-loader-runtime';
+import { parseDocument } from './parser.js';
 import { optimizeDocumentNode, removeDescriptions, removeEmptyNodes } from '@graphql-tools/optimize';
-
-/**
- * Strip insignificant whitespace
- * Note that this could do a lot more, such as reorder fields etc.
- */
-function normalize(str) {
-    return str.replace(/[\s,]+/g, ' ').trim();
-}
-// A map docString -> graphql document
-const docCache = {};
-// A map fragmentName -> [normalized source]
-const fragmentSourceMap = {};
-function cacheKeyFromFragment(fragment) {
-    return normalize(print(fragment));
-}
-/**
- * Take a unstripped parsed document (query/mutation or even fragment), and
- * check all fragment definitions, checking for name->source uniqueness.
- * We also want to make sure only unique fragments exist in the document.
- */
-function processFragments(ast) {
-    const astFragmentMap = {};
-    const definitions = [];
-    for (let i = 0; i < ast.definitions.length; i++) {
-        const fragmentDefinition = ast.definitions[i];
-        if (fragmentDefinition.kind === Kind.FRAGMENT_DEFINITION) {
-            const fragmentName = fragmentDefinition.name.value;
-            const sourceKey = cacheKeyFromFragment(fragmentDefinition);
-            // We know something about this fragment
-            if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {
-                fragmentSourceMap[fragmentName][sourceKey] = true;
-            }
-            else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {
-                fragmentSourceMap[fragmentName] = {};
-                fragmentSourceMap[fragmentName][sourceKey] = true;
-            }
-            if (!astFragmentMap[sourceKey]) {
-                astFragmentMap[sourceKey] = true;
-                definitions.push(fragmentDefinition);
-            }
-        }
-        else {
-            definitions.push(fragmentDefinition);
-        }
-    }
-    ast.definitions = definitions;
-    return ast;
-}
-function parseDocument(doc) {
-    const cacheKey = normalize(doc);
-    if (docCache[cacheKey]) {
-        return docCache[cacheKey];
-    }
-    const parsed = parse(doc, {
-        noLocation: true,
-    });
-    if (!parsed || parsed.kind !== 'Document') {
-        throw new Error('Not a valid GraphQL document.');
-    }
-    // check that all "new" fragments inside the documents are consistent with
-    // existing fragments of the same name
-    docCache[cacheKey] = processFragments(parsed);
-    return parsed;
-}
-
 function isSDL(doc) {
     return !doc.definitions.some(def => isExecutableDefinitionNode(def));
 }
@@ -91,7 +27,7 @@ function expandImports(source, options) {
     });
     return outputCode;
 }
-function graphqlLoader(source) {
+export default function graphqlLoader(source) {
     this.cacheable();
     // TODO: This should probably use this.getOptions()
     const options = this.query || {};
@@ -143,5 +79,3 @@ function graphqlLoader(source) {
     const allCode = [headerCode, importOutputCode, outputCode, ''].join(os.EOL);
     return allCode;
 }
-
-export default graphqlLoader;

package/esm/parser.js

@@ -0,0 +1,64 @@
+import { parse, print, Kind } from 'graphql';
+/**
+ * Strip insignificant whitespace
+ * Note that this could do a lot more, such as reorder fields etc.
+ */
+function normalize(str) {
+    return str.replace(/[\s,]+/g, ' ').trim();
+}
+// A map docString -> graphql document
+const docCache = {};
+// A map fragmentName -> [normalized source]
+const fragmentSourceMap = {};
+function cacheKeyFromFragment(fragment) {
+    return normalize(print(fragment));
+}
+/**
+ * Take a unstripped parsed document (query/mutation or even fragment), and
+ * check all fragment definitions, checking for name->source uniqueness.
+ * We also want to make sure only unique fragments exist in the document.
+ */
+function processFragments(ast) {
+    const astFragmentMap = {};
+    const definitions = [];
+    for (let i = 0; i < ast.definitions.length; i++) {
+        const fragmentDefinition = ast.definitions[i];
+        if (fragmentDefinition.kind === Kind.FRAGMENT_DEFINITION) {
+            const fragmentName = fragmentDefinition.name.value;
+            const sourceKey = cacheKeyFromFragment(fragmentDefinition);
+            // We know something about this fragment
+            if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {
+                fragmentSourceMap[fragmentName][sourceKey] = true;
+            }
+            else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {
+                fragmentSourceMap[fragmentName] = {};
+                fragmentSourceMap[fragmentName][sourceKey] = true;
+            }
+            if (!astFragmentMap[sourceKey]) {
+                astFragmentMap[sourceKey] = true;
+                definitions.push(fragmentDefinition);
+            }
+        }
+        else {
+            definitions.push(fragmentDefinition);
+        }
+    }
+    ast.definitions = definitions;
+    return ast;
+}
+export function parseDocument(doc) {
+    const cacheKey = normalize(doc);
+    if (docCache[cacheKey]) {
+        return docCache[cacheKey];
+    }
+    const parsed = parse(doc, {
+        noLocation: true,
+    });
+    if (!parsed || parsed.kind !== 'Document') {
+        throw new Error('Not a valid GraphQL document.');
+    }
+    // check that all "new" fragments inside the documents are consistent with
+    // existing fragments of the same name
+    docCache[cacheKey] = processFragments(parsed);
+    return parsed;
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/webpack-loader",
-  "version": "6.6.3",
+  "version": "6.7.0-alpha-80e1b48b.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/optimize": "1.2.1",
-    "@graphql-tools/webpack-loader-runtime": "6.3.1",
+    "@graphql-tools/optimize": "1.3.0-alpha-80e1b48b.0",
+    "@graphql-tools/webpack-loader-runtime": "6.4.0-alpha-80e1b48b.0",
     "tslib": "^2.4.0"
   },
   "repository": {
@@ -17,21 +17,42 @@
     "directory": "packages/webpack-loader"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/index.js

@@ -1,151 +0,0 @@
-'use strict';
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const os = _interopDefault(require('os'));
-const graphql = require('graphql');
-const webpackLoaderRuntime = require('@graphql-tools/webpack-loader-runtime');
-const optimize = require('@graphql-tools/optimize');
-
-/**
- * Strip insignificant whitespace
- * Note that this could do a lot more, such as reorder fields etc.
- */
-function normalize(str) {
-    return str.replace(/[\s,]+/g, ' ').trim();
-}
-// A map docString -> graphql document
-const docCache = {};
-// A map fragmentName -> [normalized source]
-const fragmentSourceMap = {};
-function cacheKeyFromFragment(fragment) {
-    return normalize(graphql.print(fragment));
-}
-/**
- * Take a unstripped parsed document (query/mutation or even fragment), and
- * check all fragment definitions, checking for name->source uniqueness.
- * We also want to make sure only unique fragments exist in the document.
- */
-function processFragments(ast) {
-    const astFragmentMap = {};
-    const definitions = [];
-    for (let i = 0; i < ast.definitions.length; i++) {
-        const fragmentDefinition = ast.definitions[i];
-        if (fragmentDefinition.kind === graphql.Kind.FRAGMENT_DEFINITION) {
-            const fragmentName = fragmentDefinition.name.value;
-            const sourceKey = cacheKeyFromFragment(fragmentDefinition);
-            // We know something about this fragment
-            if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {
-                fragmentSourceMap[fragmentName][sourceKey] = true;
-            }
-            else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {
-                fragmentSourceMap[fragmentName] = {};
-                fragmentSourceMap[fragmentName][sourceKey] = true;
-            }
-            if (!astFragmentMap[sourceKey]) {
-                astFragmentMap[sourceKey] = true;
-                definitions.push(fragmentDefinition);
-            }
-        }
-        else {
-            definitions.push(fragmentDefinition);
-        }
-    }
-    ast.definitions = definitions;
-    return ast;
-}
-function parseDocument(doc) {
-    const cacheKey = normalize(doc);
-    if (docCache[cacheKey]) {
-        return docCache[cacheKey];
-    }
-    const parsed = graphql.parse(doc, {
-        noLocation: true,
-    });
-    if (!parsed || parsed.kind !== 'Document') {
-        throw new Error('Not a valid GraphQL document.');
-    }
-    // check that all "new" fragments inside the documents are consistent with
-    // existing fragments of the same name
-    docCache[cacheKey] = processFragments(parsed);
-    return parsed;
-}
-
-function isSDL(doc) {
-    return !doc.definitions.some(def => graphql.isExecutableDefinitionNode(def));
-}
-function expandImports(source, options) {
-    const lines = source.split(/\r\n|\r|\n/);
-    let outputCode = options.importHelpers
-        ? `
-    var useUnique = require('@graphql-tools/webpack-loader-runtime').useUnique;
-    var unique = useUnique();
-  `
-        : `
-    ${webpackLoaderRuntime.uniqueCode}
-  `;
-    lines.some(line => {
-        if (line[0] === '#' && line.slice(1).split(' ')[0] === 'import') {
-            const importFile = line.slice(1).split(' ')[1];
-            const parseDocument = `require(${importFile})`;
-            const appendDef = `doc.definitions = doc.definitions.concat(unique(${parseDocument}.definitions));`;
-            outputCode += appendDef + os.EOL;
-        }
-        return line.length !== 0 && line[0] !== '#';
-    });
-    return outputCode;
-}
-function graphqlLoader(source) {
-    this.cacheable();
-    // TODO: This should probably use this.getOptions()
-    const options = this.query || {};
-    let doc = parseDocument(source);
-    const optimizers = [];
-    if (options.noDescription) {
-        optimizers.push(optimize.removeDescriptions);
-    }
-    if (options.noEmptyNodes) {
-        optimizers.push(optimize.removeEmptyNodes);
-    }
-    if (optimizers.length > 0 && isSDL(doc)) {
-        doc = optimize.optimizeDocumentNode(doc, optimizers);
-    }
-    let stringifiedDoc = JSON.stringify(doc);
-    if (options.replaceKinds) {
-        for (const identifier in graphql.Kind) {
-            const value = graphql.Kind[identifier];
-            stringifiedDoc = stringifiedDoc.replace(new RegExp(`"kind":"${value}"`, 'g'), `"kind": Kind.${identifier}`);
-        }
-    }
-    const headerCode = `
-    ${options.replaceKinds ? "var Kind = require('graphql/language/kinds');" : ''}
-    var doc = ${stringifiedDoc};
-  `;
-    let outputCode = '';
-    // Allow multiple query/mutation definitions in a file. This parses out dependencies
-    // at compile time, and then uses those at load time to create minimal query documents
-    // We cannot do the latter at compile time due to how the #import code works.
-    const operationCount = doc.definitions.reduce((accum, op) => {
-        if (op.kind === graphql.Kind.OPERATION_DEFINITION) {
-            return accum + 1;
-        }
-        return accum;
-    }, 0);
-    function exportDefaultStatement(identifier) {
-        if (options.esModule) {
-            return `export default ${identifier}`;
-        }
-        return `module.exports = ${identifier}`;
-    }
-    if (operationCount > 1) {
-        throw new Error('GraphQL Webpack Loader allows only for one GraphQL Operation per file');
-    }
-    outputCode += `
-    ${exportDefaultStatement('doc')}
-  `;
-    const importOutputCode = expandImports(source, options);
-    const allCode = [headerCode, importOutputCode, outputCode, ''].join(os.EOL);
-    return allCode;
-}
-
-module.exports = graphqlLoader;