eddev 0.2.67-beta1 → 0.3.0-beta2

package/build/graphql-codegen/graphql-codegen-files.js

@@ -3,22 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const glob_promise_1 = require("glob-promise");
-const path_1 = __importDefault(require("path"));
+var glob_promise_1 = require("glob-promise");
+var path_1 = __importDefault(require("path"));
 module.exports = {
-    plugin: (schema, documents, config, info) => {
-        const folder = path_1.default.resolve(config.rootDir, config.folderName);
-        const imports = [];
-        const items = [];
-        const files = glob_promise_1.glob.sync(folder + "/**/*.tsx");
-        const filesFound = {};
-        const additionalTypes = config.additionalTypes || {};
+    plugin: function (schema, documents, config, info) {
+        var folder = path_1.default.resolve(config.rootDir, config.folderName);
+        var imports = [];
+        var items = [];
+        var files = glob_promise_1.glob.sync(folder + "/**/*.tsx");
+        var filesFound = {};
+        var additionalTypes = config.additionalTypes || {};
         // const additionalTypes: Record<string, string> = {
         //   "_html.tsx": `{ "template": string, "htmlContent": string }`,
         // }
-        const getRelative = (path) => path_1.default.relative(folder, path);
-        const typeForFile = (file, baseType) => {
-            const types = [];
+        var getRelative = function (path) { return path_1.default.relative(folder, path); };
+        var typeForFile = function (file, baseType) {
+            var types = [];
             if (baseType)
                 types.push(baseType);
             if (additionalTypes[file]) {
@@ -31,40 +31,34 @@ module.exports = {
                 return types.join(" & ");
             }
         };
-        documents.forEach((doc) => {
+        documents.forEach(function (doc) {
+            var _a;
             if (!doc.location.startsWith(folder))
                 return;
             filesFound[doc.location.replace(/\.graphql/, "")] = true;
-            const relative = getRelative(doc.location);
+            var relative = getRelative(doc.location);
             // const docsNames = doc.document.definitions.map(
             //   (def: any) => def.name.value
             // )
             if (relative && doc.document.definitions.length) {
-                let importedName = doc.document.definitions[0].name.value + "Query";
-                let typeName = config.getType?.(importedName, doc.document.definitions[0]) || importedName;
+                var importedName = doc.document.definitions[0].name.value + "Query";
+                var typeName = ((_a = config.getType) === null || _a === void 0 ? void 0 : _a.call(config, importedName, doc.document.definitions[0])) || importedName;
                 imports.push(importedName);
-                const key = relative.replace(/\.graphql/, "");
-                items.push(`${JSON.stringify(key)}: ${typeForFile(key, typeName)}`);
+                var key = relative.replace(/\.graphql/, "");
+                items.push("".concat(JSON.stringify(key), ": ").concat(typeForFile(key, typeName)));
             }
         });
-        for (const file of files) {
+        for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+            var file = files_1[_i];
             if (!filesFound[file.replace(/\.tsx/, "")]) {
-                const key = getRelative(file).replace(/\.tsx$/, "");
-                items.push(`${JSON.stringify(key)}: ${typeForFile(key, "")}`);
+                var key = getRelative(file).replace(/\.tsx$/, "");
+                items.push("".concat(JSON.stringify(key), ": ").concat(typeForFile(key, "")));
             }
         }
         if (imports.length === 0) {
             process.exit();
-            return `export { };`;
+            return "export { };";
         }
-        return `import { ${imports.sort().join(", ")} } from "./types.graphql"
-export { };
-
-declare global {
-  type ${config.globalName} = {
-${items.sort().join(",\n")}
-  }
-}
-      `;
+        return "import { ".concat(imports.sort().join(", "), " } from \"./types.graphql\"\nexport { };\n\ndeclare global {\n  type ").concat(config.globalName, " = {\n").concat(items.sort().join(",\n"), "\n  }\n}\n      ");
     },
 };

package/build/graphql-codegen/graphql-codegen-no-duplicates.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 module.exports = {
-    plugin: () => { },
-    validate: (schema, documents, config, info) => {
-        documents.forEach((doc) => {
+    plugin: function () { },
+    validate: function (schema, documents, config, info) {
+        documents.forEach(function (doc) {
             if (doc.document.definitions.length === 0) {
-                throw new Error(`GraphQL file '${doc.location}' does not contain any uniquely named operations.`);
+                throw new Error("GraphQL file '".concat(doc.location, "' does not contain any uniquely named operations."));
                 process.exit();
             }
         });

package/build/graphql-codegen/graphql-codegen-queries.js

@@ -1,23 +1,33 @@
 "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 });
-const graphql_1 = require("graphql");
-const path_1 = require("path");
+var graphql_1 = require("graphql");
+var path_1 = require("path");
 module.exports = {
-    plugin: (schema, documents, config, info) => {
-        const hooks = {};
-        const importTypes = [];
-        const importUtils = {};
-        documents.forEach((doc) => {
-            const fullFileName = doc.location;
-            const fileName = doc.location.replace(config.rootDir, "");
+    plugin: function (schema, documents, config, info) {
+        var hooks = {};
+        var importTypes = [];
+        var importUtils = {};
+        documents.forEach(function (doc) {
+            var fullFileName = doc.location;
+            var fileName = doc.location.replace(config.rootDir, "");
             if (doc.document.definitions.length) {
-                let foundQueryOperation = false;
-                doc.document.definitions.forEach((item) => {
+                var foundQueryOperation_1 = false;
+                doc.document.definitions.forEach(function (item) {
+                    var _a, _b, _c;
                     // We only care about 'operations'
                     if (item.kind !== "OperationDefinition" || !item.name)
                         return;
                     function throwErrorAtLocation(loc, message) {
-                        let printedSource = "";
+                        var printedSource = "";
                         if (loc && loc.source) {
                             loc.source.name = fileName;
                             printedSource = (0, graphql_1.printSourceLocation)(loc.source, {
@@ -25,45 +35,45 @@ module.exports = {
                                 column: loc.startToken.column,
                             });
                         }
-                        let fullMessage = message;
+                        var fullMessage = message;
                         if (printedSource) {
                             fullMessage += ":\n\n" + printedSource;
                         }
                         else {
-                            fullMessage += ` (in ${fileName})`;
+                            fullMessage += " (in ".concat(fileName, ")");
                         }
-                        const err = new Error(fullMessage);
+                        var err = new Error(fullMessage);
                         err.name = "QueryError";
                         throw err;
                     }
                     // Ensure only ONE operation per query file
-                    if (foundQueryOperation) {
+                    if (foundQueryOperation_1) {
                         throwErrorAtLocation(item.loc, "Only one operation is allowed in each queries/*.graphql file");
                     }
-                    foundQueryOperation = true;
+                    foundQueryOperation_1 = true;
                     /**
                      * Determine the 'hook type'
                      * - 'mutation' if the operation starts with 'mutation' instead of 'query'
                      * - 'infinite' if the operation contains the word 'infinite'
                      * - 'normal' otherwise
                      */
-                    const type = item.operation === "mutation" ? "mutation" : item.name.value.match(/infinite/i) ? "infinite" : "normal";
-                    const name = item.name.value;
-                    const hookName = "use" + name.replace(/^use/i, "").replace(/^[a-z]/, (c) => c.toUpperCase());
-                    const variablesTypeName = item.variableDefinitions?.length
+                    var type = item.operation === "mutation" ? "mutation" : item.name.value.match(/infinite/i) ? "infinite" : "normal";
+                    var name = item.name.value;
+                    var hookName = "use" + name.replace(/^use/i, "").replace(/^[a-z]/, function (c) { return c.toUpperCase(); });
+                    var variablesTypeName = ((_a = item.variableDefinitions) === null || _a === void 0 ? void 0 : _a.length)
                         ? type === "mutation"
                             ? name + "MutationVariables"
                             : name + "QueryVariables"
                         : null;
-                    const resultTypeName = name + (type === "mutation" ? "Mutation" : "Query");
+                    var resultTypeName = name + (type === "mutation" ? "Mutation" : "Query");
                     // For conventions sake, the name of the operation should start with 'Use'
                     if (!name.match(/^Use/)) {
-                        throwErrorAtLocation(item.name.loc, `Expected your query name to start with 'Use', but found '${name}'. Did you mean 'Use${name}'`);
+                        throwErrorAtLocation(item.name.loc, "Expected your query name to start with 'Use', but found '".concat(name, "'. Did you mean 'Use").concat(name, "'"));
                     }
                     // Another convention, the query name and file name should be the same
-                    const baseName = (0, path_1.basename)(fileName);
+                    var baseName = (0, path_1.basename)(fileName);
                     if (baseName.replace(".graphql", "") !== name) {
-                        throwErrorAtLocation(item.name.loc, `Expected your query name and file name to match, for conventions sake (eg. '${baseName}' should be '${name}.graphql')`);
+                        throwErrorAtLocation(item.name.loc, "Expected your query name and file name to match, for conventions sake (eg. '".concat(baseName, "' should be '").concat(name, ".graphql')"));
                     }
                     // Only import variables if the operation has variables
                     if (variablesTypeName) {
@@ -73,178 +83,165 @@ module.exports = {
                     if (type === "normal") {
                         // Just a normal query!
                         importUtils["createUseQuery"] = true;
-                        hooks[hookName] = `
-              createUseQuery<${resultTypeName}, ${variablesTypeName || "undefined"}>({
-                name: ${JSON.stringify(name)}
-              })
-            `;
+                        hooks[hookName] = "\n              createUseQuery<".concat(resultTypeName, ", ").concat(variablesTypeName || "undefined", ">({\n                name: ").concat(JSON.stringify(name), "\n              })\n            ");
                     }
                     else if (type === "mutation") {
                         // A triggerable mutation
                         importUtils["createUseMutation"] = true;
-                        hooks[hookName] = `
-              createUseMutation<${resultTypeName}, ${variablesTypeName || "undefined"}>({
-                name: ${JSON.stringify(name)}
-              })
-            `;
+                        hooks[hookName] = "\n              createUseMutation<".concat(resultTypeName, ", ").concat(variablesTypeName || "undefined", ">({\n                name: ").concat(JSON.stringify(name), "\n              })\n            ");
                     }
                     else if (type === "infinite") {
                         // Ensure the query has 'limit' and 'cursor' variables
-                        let limitVariableIsValid = false;
-                        let cursorVariableIsValid = false;
-                        let defaultLimit = 0;
-                        item.variableDefinitions?.forEach((item) => {
-                            const { variable, type, loc, defaultValue } = item;
-                            if (variable?.name?.value === "limit") {
+                        var limitVariableIsValid_1 = false;
+                        var cursorVariableIsValid_1 = false;
+                        var defaultLimit_1 = 0;
+                        (_b = item.variableDefinitions) === null || _b === void 0 ? void 0 : _b.forEach(function (item) {
+                            var _a, _b;
+                            var variable = item.variable, type = item.type, loc = item.loc, defaultValue = item.defaultValue;
+                            if (((_a = variable === null || variable === void 0 ? void 0 : variable.name) === null || _a === void 0 ? void 0 : _a.value) === "limit") {
                                 // Found 'limit', but make sure it's an Int, and has a default value
                                 if (type.kind === "NamedType" && type.name.value === "Int") {
                                     if (defaultValue && defaultValue.kind === "IntValue") {
-                                        limitVariableIsValid = true;
-                                        defaultLimit = Number(defaultValue.value);
+                                        limitVariableIsValid_1 = true;
+                                        defaultLimit_1 = Number(defaultValue.value);
                                     }
                                     else {
-                                        throwErrorAtLocation(loc, `For infinite queries, be sure to give the '$limit' variable a default value!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                        throwErrorAtLocation(loc, "For infinite queries, be sure to give the '$limit' variable a default value!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks");
                                     }
                                 }
                                 else {
                                     // @ts-ignore
-                                    const wrongType = type?.name?.value;
-                                    throwErrorAtLocation(loc, `For infinite queries, the '$limit' variable is expected to be an 'Int' type, but you've used '${wrongType}' instead!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                    var wrongType = (_b = type === null || type === void 0 ? void 0 : type.name) === null || _b === void 0 ? void 0 : _b.value;
+                                    throwErrorAtLocation(loc, "For infinite queries, the '$limit' variable is expected to be an 'Int' type, but you've used '".concat(wrongType, "' instead!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks"));
                                 }
                             }
                             else if (variable.name.value === "cursor") {
                                 // Found 'cursor', but make sure it's a string
                                 if (type.kind === "NamedType") {
                                     if (type.name.value === "String") {
-                                        cursorVariableIsValid = true;
+                                        cursorVariableIsValid_1 = true;
                                     }
                                     else {
-                                        throwErrorAtLocation(loc, `For infinite queries, the required '$cursor' variable must be an optional String.\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                        throwErrorAtLocation(loc, "For infinite queries, the required '$cursor' variable must be an optional String.\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks");
                                     }
                                 }
                             }
                         });
                         // Check that both the 'limit' and 'cursor' variables are present!
-                        if (!cursorVariableIsValid || !limitVariableIsValid) {
-                            throwErrorAtLocation(item.loc, `For infinite queries, you must supply and use the '$limit' and '$cursor' variables\nFor example: posts($limit: Int = 10, $cursor: String) ${cursorVariableIsValid} ${limitVariableIsValid}\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        if (!cursorVariableIsValid_1 || !limitVariableIsValid_1) {
+                            throwErrorAtLocation(item.loc, "For infinite queries, you must supply and use the '$limit' and '$cursor' variables\nFor example: posts($limit: Int = 10, $cursor: String) ".concat(cursorVariableIsValid_1, " ").concat(limitVariableIsValid_1, "\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks"));
                         }
                         // Finally, ensure that pageInfo is queried somewhere
                         // We actually want the selection path for a whole bunch of fields, so that we can extract pagination info, and the list of data
-                        const pageInfo = {
+                        var pageInfo_1 = {
                             nodesPath: null,
                             pageInfoPath: null,
                             endCursorPath: null,
                             hasNextPagePath: null,
                         };
-                        let nodesPaths = [];
+                        var nodesPaths_1 = [];
                         // To do this, we use the visitor pattern to find the pageInfo field selection
-                        let lookingAtPageInfo = true;
-                        let lookupPath = [];
-                        let parentNode;
+                        var lookingAtPageInfo_1 = true;
+                        var lookupPath_1 = [];
+                        var parentNode_1;
                         (0, graphql_1.visit)(item.selectionSet, {
-                            enter(node, key, parent, path, ancestors) {
+                            enter: function (node, key, parent, path, ancestors) {
                                 if (node.kind === "Field") {
-                                    lookupPath = [...lookupPath, node.name.value];
+                                    lookupPath_1 = __spreadArray(__spreadArray([], lookupPath_1, true), [node.name.value], false);
                                     if (node.name.value === "pageInfo") {
-                                        parentNode = ancestors[ancestors.length - 2];
+                                        parentNode_1 = ancestors[ancestors.length - 2];
                                         // parentNode = ancestors
-                                        if (pageInfo.pageInfoPath) {
+                                        if (pageInfo_1.pageInfoPath) {
                                             // Detected multiple pageInfo fields in the query — confusing!
-                                            throwErrorAtLocation(node.loc, `For infinite queries, be sure to only use 'pageInfo' once. Multiple 'pageInfo' fields were selected in your query!`);
+                                            throwErrorAtLocation(node.loc, "For infinite queries, be sure to only use 'pageInfo' once. Multiple 'pageInfo' fields were selected in your query!");
                                         }
-                                        lookingAtPageInfo = true;
-                                        pageInfo.pageInfoPath = lookupPath;
+                                        lookingAtPageInfo_1 = true;
+                                        pageInfo_1.pageInfoPath = lookupPath_1;
                                     }
                                     else if (node.name.value === "nodes") {
-                                        nodesPaths.push(lookupPath);
+                                        nodesPaths_1.push(lookupPath_1);
                                     }
-                                    else if (lookingAtPageInfo) {
+                                    else if (lookingAtPageInfo_1) {
                                         if (node.name.value === "endCursor") {
-                                            pageInfo.endCursorPath = lookupPath;
+                                            pageInfo_1.endCursorPath = lookupPath_1;
                                         }
                                         else if (node.name.value === "hasNextPage") {
-                                            pageInfo.hasNextPagePath = lookupPath;
+                                            pageInfo_1.hasNextPagePath = lookupPath_1;
                                         }
                                     }
                                 }
                             },
-                            leave(node, key, parent, path, ancestors) {
+                            leave: function (node, key, parent, path, ancestors) {
                                 if (node.kind === "Field") {
-                                    lookupPath = lookupPath.slice(0, -1);
+                                    lookupPath_1 = lookupPath_1.slice(0, -1);
                                     if (node.name.value === "pageInfo") {
-                                        lookingAtPageInfo = false;
+                                        lookingAtPageInfo_1 = false;
                                     }
                                 }
                             },
                         });
                         // Make sure we found pageInfo { endCursor, hasNextPage }
-                        if (!pageInfo.pageInfoPath || !pageInfo.endCursorPath || !pageInfo.hasNextPagePath) {
-                            throwErrorAtLocation(undefined, `For infinite queries, you need to ensure you select the 'pageInfo' field and it's child 'hasNextPage' and 'endCursor' fields\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        if (!pageInfo_1.pageInfoPath || !pageInfo_1.endCursorPath || !pageInfo_1.hasNextPagePath) {
+                            throwErrorAtLocation(undefined, "For infinite queries, you need to ensure you select the 'pageInfo' field and it's child 'hasNextPage' and 'endCursor' fields\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks");
                         }
                         // Look for a nodes path which shares the same parent as the pageInfo path
-                        const expectedNodesPath = pageInfo.pageInfoPath.slice(0, -1).join(",");
-                        pageInfo.nodesPath = nodesPaths.find((path) => {
-                            const testPath = path.slice(0, -1).join(",");
-                            return testPath === expectedNodesPath;
+                        var expectedNodesPath_1 = pageInfo_1.pageInfoPath.slice(0, -1).join(",");
+                        pageInfo_1.nodesPath = nodesPaths_1.find(function (path) {
+                            var testPath = path.slice(0, -1).join(",");
+                            return testPath === expectedNodesPath_1;
                         });
-                        if (!pageInfo.nodesPath || !parentNode) {
-                            throwErrorAtLocation(undefined, `For infinite queries, be sure to select some nodes using the 'nodes' field, adjacent to the 'pageInfo' field which has been selected.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        if (!pageInfo_1.nodesPath || !parentNode_1) {
+                            throwErrorAtLocation(undefined, "For infinite queries, be sure to select some nodes using the 'nodes' field, adjacent to the 'pageInfo' field which has been selected.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks");
                         }
-                        let firstArgumentIsValid = false;
-                        let afterArgumentIsValid = false;
-                        parentNode?.arguments?.forEach((arg) => {
+                        var firstArgumentIsValid_1 = false;
+                        var afterArgumentIsValid_1 = false;
+                        (_c = parentNode_1 === null || parentNode_1 === void 0 ? void 0 : parentNode_1.arguments) === null || _c === void 0 ? void 0 : _c.forEach(function (arg) {
                             if (arg.kind === "Argument") {
                                 if (arg.name.value === "first") {
                                     if (arg.value.kind === "Variable") {
                                         if (arg.value.name.value === "limit") {
-                                            firstArgumentIsValid = true;
+                                            firstArgumentIsValid_1 = true;
                                         }
                                     }
                                 }
                                 if (arg.name.value === "after") {
                                     if (arg.value.kind === "Variable") {
                                         if (arg.value.name.value === "cursor") {
-                                            afterArgumentIsValid = true;
+                                            afterArgumentIsValid_1 = true;
                                         }
                                     }
                                 }
                             }
                         });
-                        if (parentNode && (!firstArgumentIsValid || !afterArgumentIsValid)) {
-                            throwErrorAtLocation(parentNode.loc, `You must use the arguments (first: $limit, after: $cursor) when using infinite queries.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        if (parentNode_1 && (!firstArgumentIsValid_1 || !afterArgumentIsValid_1)) {
+                            throwErrorAtLocation(parentNode_1.loc, "You must use the arguments (first: $limit, after: $cursor) when using infinite queries.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks");
                         }
                         // Drill down to the path type
-                        let finalResultTypeName = resultTypeName;
-                        pageInfo.nodesPath.forEach((key) => {
-                            finalResultTypeName = `Exclude<${finalResultTypeName}[${JSON.stringify(key)}], undefined | null>`;
+                        var finalResultTypeName_1 = resultTypeName;
+                        pageInfo_1.nodesPath.forEach(function (key) {
+                            finalResultTypeName_1 = "Exclude<".concat(finalResultTypeName_1, "[").concat(JSON.stringify(key), "], undefined | null>");
                         });
                         importUtils["createUseInfiniteQuery"] = true;
-                        hooks[hookName] = `
-              createUseInfiniteQuery<Exclude<${finalResultTypeName}[0], undefined | null>, Omit<${variablesTypeName || "undefined"}, 'limit' | 'cursor'>>({
-                name: ${JSON.stringify(name)},
-                defaultLimit: ${defaultLimit},
-                paths: ${JSON.stringify(pageInfo)}
-              })
-            `;
+                        hooks[hookName] = "\n              createUseInfiniteQuery<Exclude<".concat(finalResultTypeName_1, "[0], undefined | null>, Omit<").concat(variablesTypeName || "undefined", ", 'limit' | 'cursor'>>({\n                name: ").concat(JSON.stringify(name), ",\n                defaultLimit: ").concat(defaultLimit_1, ",\n                paths: ").concat(JSON.stringify(pageInfo_1), "\n              })\n            ");
                     }
                 });
             }
         });
-        const utilsToImport = Object.keys(importUtils);
+        var utilsToImport = Object.keys(importUtils);
         if (!utilsToImport)
-            return `export {}`;
-        const codeBlocks = [];
+            return "export {}";
+        var codeBlocks = [];
         // Import required utility functions
         if (utilsToImport.length) {
-            codeBlocks.push(`import { ${utilsToImport.join(", ")} } from 'eddev/hooks/queryUtils'`);
+            codeBlocks.push("import { ".concat(utilsToImport.join(", "), " } from 'eddev/hooks/queryUtils'"));
         }
         // Import types from types.graphql
         if (importTypes.length) {
-            codeBlocks.push(`import { ${importTypes} } from '../types.graphql'`);
+            codeBlocks.push("import { ".concat(importTypes, " } from '../types.graphql'"));
         }
-        for (const hookName in hooks) {
-            const hookCode = hooks[hookName];
-            codeBlocks.push(`export const ${hookName} = ${hookCode}`);
+        for (var hookName in hooks) {
+            var hookCode = hooks[hookName];
+            codeBlocks.push("export const ".concat(hookName, " = ").concat(hookCode));
         }
         return codeBlocks.join("\n\n");
     },

package/build/manifests/manifest-blocks.d.ts

@@ -1,4 +1,4 @@
-type Options = {
+declare type Options = {
     baseDirectory: string;
     isAdmin: boolean;
     isDev: boolean;

package/build/manifests/manifest-blocks.js

@@ -4,65 +4,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBlockManifestGenerator = void 0;
-const manifest_1 = require("./manifest");
-const path_1 = __importDefault(require("path"));
-const change_case_1 = require("change-case");
-const fs_1 = require("fs");
-const JSX = /\.(jsx|tsx|ts|js)$/i;
+var manifest_1 = require("./manifest");
+var path_1 = __importDefault(require("path"));
+var change_case_1 = require("change-case");
+var fs_1 = require("fs");
+var JSX = /\.(jsx|tsx|ts|js)$/i;
 function createBlockManifestGenerator(opts) {
     return (0, manifest_1.createManifestGenerator)({
         glob: path_1.default.join(opts.baseDirectory, "/blocks/**/*.tsx"),
         onGenerate: opts.onGenerate,
         watch: opts.watch,
-        generate(fileNames) {
-            const files = fileNames
-                .filter((file) => !file.includes("/_core"))
-                .map((file) => {
-                const relative = path_1.default.relative(opts.baseDirectory, file).replace(JSX, "");
-                const name = path_1.default.basename(file).replace(JSX, "");
-                const module = JSON.stringify("./" + relative).replace(JSX, "");
-                const componentName = (0, change_case_1.pascalCase)(name);
+        generate: function (fileNames) {
+            var files = fileNames
+                .filter(function (file) { return !file.includes("/_core"); })
+                .map(function (file) {
+                var relative = path_1.default.relative(opts.baseDirectory, file).replace(JSX, "");
+                var name = path_1.default.basename(file).replace(JSX, "");
+                var module = JSON.stringify("./" + relative).replace(JSX, "");
+                var componentName = (0, change_case_1.pascalCase)(name);
                 // Test if the block has Dynamic: true in the header
-                const dynamic = !opts.isAdmin &&
+                var dynamic = !opts.isAdmin &&
                     !!(0, fs_1.readFileSync)(file)
                         .toString()
                         .match(/\*[\s]*dynamic: true/i);
-                return { relative, name, module, componentName, dynamic };
+                return { relative: relative, name: name, module: module, componentName: componentName, dynamic: dynamic };
             });
-            return `
-        import coreBlocks from './blocks/_core'
-        import { dynamic } from 'eddev/dynamic';
-  
-        ${files
-                .map(({ relative, componentName, module, dynamic }) => {
-                const parts = relative.replace(/\.tsx$/, "").split("/");
-                const blockName = "acf/" + parts.slice(1).join("-");
+            return "\n        import coreBlocks from './blocks/_core'\n        import { dynamic } from 'eddev/dynamic';\n  \n        ".concat(files
+                .map(function (_a) {
+                var relative = _a.relative, componentName = _a.componentName, module = _a.module, dynamic = _a.dynamic;
+                var parts = relative.replace(/\.tsx$/, "").split("/");
+                var blockName = "acf/" + parts.slice(1).join("-");
                 if (dynamic) {
                     return null;
                 }
                 else {
-                    return `import ${componentName} from ${module}`;
+                    return "import ".concat(componentName, " from ").concat(module);
                 }
             })
                 .filter(Boolean)
-                .join("\n")}
-  
-        export default {
-          ...coreBlocks,
-          ${files
-                .map(({ relative, componentName, module, dynamic }) => {
-                const parts = relative.replace(/\.tsx$/, "").split("/");
-                const blockName = "acf/" + parts.slice(1).join("-");
+                .join("\n"), "\n  \n        export default {\n          ...coreBlocks,\n          ").concat(files
+                .map(function (_a) {
+                var relative = _a.relative, componentName = _a.componentName, module = _a.module, dynamic = _a.dynamic;
+                var parts = relative.replace(/\.tsx$/, "").split("/");
+                var blockName = "acf/" + parts.slice(1).join("-");
                 if (dynamic) {
-                    return `"${blockName}": dynamic(() => import(${module}))`;
+                    return "\"".concat(blockName, "\": dynamic(() => import(").concat(module, "))");
                 }
                 else {
-                    return `"${blockName}": ${componentName}`;
+                    return "\"".concat(blockName, "\": ").concat(componentName);
                 }
             })
-                .join(",\n")}
-        }
-      `;
+                .join(",\n"), "\n        }\n      ");
         },
     });
 }

package/build/manifests/manifest-fields.d.ts

@@ -1,4 +1,4 @@
-type Options = {
+declare type Options = {
     baseDirectory: string;
     isAdmin: boolean;
     isDev: boolean;