@plasmicapp/loader-gatsby 1.0.254 → 1.0.256

package/dist/gatsby-node.d.ts

@@ -1,19 +1,11 @@
 import { InitOptions } from "@plasmicapp/loader-react";
-import { CreatePagesArgs, GatsbyNode } from "gatsby";
-export declare const onPreInit: ({ reporter }: {
-    reporter: any;
-}) => any;
-export type GatsbyPluginOptions = InitOptions & {
+import { GatsbyNode, PluginOptions } from "gatsby";
+export declare const onPreInit: GatsbyNode["onPreInit"];
+export type GatsbyPluginOptions = PluginOptions & InitOptions & {
     defaultPlasmicPage?: string;
     ignorePaths?: string[];
 };
-export declare const sourceNodes: ({ actions, createContentDigest, reporter }: any, opts: GatsbyPluginOptions) => Promise<void>;
+export declare const sourceNodes: GatsbyNode["sourceNodes"];
 export declare const createResolvers: GatsbyNode["createResolvers"];
-export declare const createSchemaCustomization: ({ actions }: {
-    actions: any;
-}) => void;
-interface LoaderGatsbyPluginOptions extends GatsbyPluginOptions {
-    defaultPlasmicPage: string;
-}
-export declare const createPages: ({ graphql, actions, reporter }: CreatePagesArgs, opts: LoaderGatsbyPluginOptions) => Promise<void>;
-export {};
+export declare const createSchemaCustomization: GatsbyNode["createSchemaCustomization"];
+export declare const createPages: GatsbyNode["createPages"];

package/dist/gatsby-node.js

@@ -1,285 +1,308 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPages = exports.createSchemaCustomization = exports.createResolvers = exports.sourceNodes = exports.onPreInit = void 0;
-var tslib_1 = require("tslib");
-var loader_react_1 = require("@plasmicapp/loader-react");
-var server_require_1 = tslib_1.__importDefault(require("./server-require"));
-var onPreInit = function (_a) {
-    var reporter = _a.reporter;
-    return reporter.success("Loaded @plasmicapp/loader-gatsby");
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
 };
-exports.onPreInit = onPreInit;
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/gatsby-node.ts
+var gatsby_node_exports = {};
+__export(gatsby_node_exports, {
+  createPages: () => createPages,
+  createResolvers: () => createResolvers,
+  createSchemaCustomization: () => createSchemaCustomization,
+  onPreInit: () => onPreInit,
+  sourceNodes: () => sourceNodes
+});
+module.exports = __toCommonJS(gatsby_node_exports);
+var import_loader_react = require("@plasmicapp/loader-react");
+
+// src/server-require.ts
+var secretRequire;
+try {
+  secretRequire = eval("require");
+} catch (err) {
+  secretRequire = void 0;
+}
+function serverRequire(module2) {
+  if (!secretRequire) {
+    throw new Error(
+      `Unexpected serverRequire() -- can only do this from a Node server!`
+    );
+  }
+  return secretRequire(module2);
+}
+
+// src/gatsby-node.ts
+var onPreInit = ({ reporter }) => reporter.success("Loaded @plasmicapp/loader-gatsby");
 var PLASMIC_NODE_NAME = "plasmicData";
-var PLASMIC_DATA_TYPE = "\n  type ".concat(PLASMIC_NODE_NAME, " implements Node {\n    name: String!\n    displayName: String!\n    projectId: String!\n    path: String\n    isPage: Boolean!\n    renderData: JSON!\n  }\n\n  type Query {\n    plasmicComponents(componentNames: [String]!): JSON\n    plasmicOptions: JSON\n  }\n");
-var SOURCE_WAIT_TIME = 3000; // 3 seconds
-var SOURCE_MAX_WAIT_TIME = 10000; // 10 seconds
+var PLASMIC_DATA_TYPE = `
+  type ${PLASMIC_NODE_NAME} implements Node {
+    name: String!
+    displayName: String!
+    projectId: String!
+    path: String
+    isPage: Boolean!
+    renderData: JSON!
+  }
+
+  type Query {
+    plasmicComponents(componentNames: [String]!): JSON
+    plasmicOptions: JSON
+  }
+`;
+var SOURCE_WAIT_TIME = 3e3;
+var SOURCE_MAX_WAIT_TIME = 1e4;
 var allPaths = [];
-var sourceNodes = function (_a, opts) {
-    var actions = _a.actions, createContentDigest = _a.createContentDigest, reporter = _a.reporter;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var createNode, deleteNode, allComponents, refreshData, debounce, triggerSourcing_1, PlasmicRemoteChangeWatcher, watcher;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    createNode = actions.createNode, deleteNode = actions.deleteNode;
-                    allComponents = [];
-                    refreshData = function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                        var PLASMIC, components, _loop_1, _i, allComponents_1, component, _a, components_1, component, renderData, curComponent, componentMeta, componentNode;
-                        return tslib_1.__generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    reporter.info("[Plasmic Loader] - Creating nodes");
-                                    PLASMIC = (0, loader_react_1.initPlasmicLoader)({
-                                        projects: opts.projects,
-                                        preview: opts.preview,
-                                        host: opts.host,
-                                        platform: "gatsby",
-                                    });
-                                    return [4 /*yield*/, PLASMIC.fetchComponents()];
-                                case 1:
-                                    components = _b.sent();
-                                    _loop_1 = function (component) {
-                                        var hasComponent = components.some(function (c) { return c.name === component.name; });
-                                        /**
-                                         * We shouldn't delete nodes that will be updated, if we delete all nodes
-                                         * and then create it again, this could case the graphql layer to have no
-                                         * plasmic data for some time, but this can be enough time to a re render
-                                         * causing components that call a graphql query to plasmic data to crash
-                                         * */
-                                        if (!hasComponent) {
-                                            deleteNode(component);
-                                            reporter.verbose("[Plasmic Loader] - Deleted node ".concat(component.name));
-                                        }
-                                    };
-                                    for (_i = 0, allComponents_1 = allComponents; _i < allComponents_1.length; _i++) {
-                                        component = allComponents_1[_i];
-                                        _loop_1(component);
-                                    }
-                                    allComponents = [];
-                                    _a = 0, components_1 = components;
-                                    _b.label = 2;
-                                case 2:
-                                    if (!(_a < components_1.length)) return [3 /*break*/, 5];
-                                    component = components_1[_a];
-                                    return [4 /*yield*/, PLASMIC.fetchComponentData({
-                                            name: component.name,
-                                            projectId: component.projectId,
-                                        })];
-                                case 3:
-                                    renderData = _b.sent();
-                                    curComponent = tslib_1.__assign(tslib_1.__assign({}, component), { renderData: renderData });
-                                    componentMeta = {
-                                        // We use the same id as curComponent.id since loader-react might
-                                        // expect the id to match plasmic component uuid.
-                                        // id: getNodeId(component.projectId, component.name),
-                                        parent: null,
-                                        children: [],
-                                        internal: {
-                                            type: PLASMIC_NODE_NAME,
-                                            contentDigest: createContentDigest(curComponent),
-                                        },
-                                    };
-                                    componentNode = Object.assign({}, curComponent, componentMeta);
-                                    createNode(componentNode);
-                                    reporter.verbose("[Plasmic Loader] - Created component node ".concat(component.name));
-                                    allComponents.push(componentNode);
-                                    _b.label = 4;
-                                case 4:
-                                    _a++;
-                                    return [3 /*break*/, 2];
-                                case 5: return [2 /*return*/];
-                            }
-                        });
-                    }); };
-                    if (process.env.NODE_ENV !== "production") {
-                        debounce = (0, server_require_1.default)("lodash/debounce");
-                        triggerSourcing_1 = debounce(refreshData, SOURCE_WAIT_TIME, {
-                            maxWait: SOURCE_MAX_WAIT_TIME,
-                        });
-                        PlasmicRemoteChangeWatcher = (0, server_require_1.default)("@plasmicapp/watcher")
-                            .PlasmicRemoteChangeWatcher;
-                        watcher = new PlasmicRemoteChangeWatcher({
-                            projects: opts.projects,
-                            host: opts.host,
-                        });
-                        watcher.subscribe({
-                            onUpdate: function () {
-                                if (opts.preview) {
-                                    triggerSourcing_1();
-                                }
-                            },
-                            onPublish: function () {
-                                if (!opts.preview) {
-                                    triggerSourcing_1();
-                                }
-                            },
-                        });
-                    }
-                    return [4 /*yield*/, refreshData()];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/];
-            }
-        });
+var sourceNodes = (_0, _1) => __async(void 0, [_0, _1], function* ({ actions, createContentDigest, reporter }, opts) {
+  const { createNode, deleteNode } = actions;
+  let allComponents = [];
+  const refreshData = () => __async(void 0, null, function* () {
+    reporter.info(`[Plasmic Loader] - Creating nodes`);
+    const PLASMIC = (0, import_loader_react.initPlasmicLoader)({
+      projects: opts.projects,
+      preview: opts.preview,
+      host: opts.host,
+      platform: "gatsby"
     });
-};
-exports.sourceNodes = sourceNodes;
-function getAllNodes(nodeModel, type) {
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var entries, _1;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, nodeModel.findAll({ type: type })];
-                case 1:
-                    entries = (_a.sent()).entries;
-                    return [2 /*return*/, Array.from(entries)];
-                case 2:
-                    _1 = _a.sent();
-                    // Gatsby < v4 does not have `nodeModel.findAll`, so we try to use the
-                    // deprecated `nodeModel.getAllNodes` instead.
-                    return [2 /*return*/, nodeModel.getAllNodes({ type: type })];
-                case 3: return [2 /*return*/];
-            }
-        });
+    const components = yield PLASMIC.fetchComponents();
+    for (const component of allComponents) {
+      const hasComponent = components.some((c) => c.name === component.name);
+      if (!hasComponent) {
+        deleteNode(component);
+        reporter.verbose(`[Plasmic Loader] - Deleted node ${component.name}`);
+      }
+    }
+    allComponents = [];
+    for (const component of components) {
+      const renderData = yield PLASMIC.fetchComponentData({
+        name: component.name,
+        projectId: component.projectId
+      });
+      const curComponent = __spreadProps(__spreadValues({}, component), {
+        renderData
+      });
+      const componentMeta = {
+        // We use the same id as curComponent.id since loader-react might
+        // expect the id to match plasmic component uuid.
+        // id: getNodeId(component.projectId, component.name),
+        parent: null,
+        children: [],
+        internal: {
+          type: PLASMIC_NODE_NAME,
+          contentDigest: createContentDigest(curComponent)
+        }
+      };
+      const componentNode = Object.assign({}, curComponent, componentMeta);
+      createNode(componentNode);
+      reporter.verbose(
+        `[Plasmic Loader] - Created component node ${component.name}`
+      );
+      allComponents.push(componentNode);
+    }
+  });
+  if (process.env.NODE_ENV !== "production") {
+    const debounce = serverRequire("lodash/debounce");
+    const triggerSourcing = debounce(refreshData, SOURCE_WAIT_TIME, {
+      maxWait: SOURCE_MAX_WAIT_TIME
     });
+    try {
+      const PlasmicRemoteChangeWatcher = serverRequire("@plasmicapp/watcher").PlasmicRemoteChangeWatcher;
+      const watcher = new PlasmicRemoteChangeWatcher({
+        projects: opts.projects,
+        host: opts.host
+      });
+      watcher.subscribe({
+        onUpdate: () => {
+          if (opts.preview) {
+            triggerSourcing();
+          }
+        },
+        onPublish: () => {
+          if (!opts.preview) {
+            triggerSourcing();
+          }
+        }
+      });
+    } catch (e) {
+      console.warn("Couldn't subscribe to Plasmic changes", e);
+    }
+  }
+  yield refreshData();
+});
+function getAllNodes(nodeModel, type) {
+  return __async(this, null, function* () {
+    try {
+      const { entries } = yield nodeModel.findAll({ type });
+      return Array.from(entries);
+    } catch (_) {
+      return nodeModel.getAllNodes({ type });
+    }
+  });
 }
-var createResolvers = function (_a, opts) {
-    var createResolvers = _a.createResolvers;
-    createResolvers({
-        Query: {
-            plasmicComponents: {
-                type: "JSON",
-                args: {
-                    componentNames: "[String]!",
-                },
-                resolve: function (_source, args, context, _info) {
-                    var _a;
-                    return tslib_1.__awaiter(this, void 0, void 0, function () {
-                        var componentNames, components, bundles, compMetas, _loop_2, _i, components_2, component, renderData;
-                        return tslib_1.__generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    componentNames = args.componentNames;
-                                    return [4 /*yield*/, getAllNodes(context.nodeModel, PLASMIC_NODE_NAME)];
-                                case 1:
-                                    components = _b.sent();
-                                    bundles = [];
-                                    compMetas = [];
-                                    _loop_2 = function (component) {
-                                        if (componentNames.includes(component.name) ||
-                                            componentNames.includes(component.displayName) ||
-                                            !!(component.path &&
-                                                componentNames.some(function (lookup) {
-                                                    return (0, loader_react_1.matchesPagePath)(component.path, lookup);
-                                                }))) {
-                                            var bundle = (_a = component.renderData) === null || _a === void 0 ? void 0 : _a.bundle;
-                                            if (bundle) {
-                                                bundles.push(bundle);
-                                                var meta = component;
-                                                // If component is a page, try to parse dynamic params.
-                                                if (component.path) {
-                                                    for (var _c = 0, componentNames_1 = componentNames; _c < componentNames_1.length; _c++) {
-                                                        var lookup = componentNames_1[_c];
-                                                        var match = (0, loader_react_1.matchesPagePath)(component.path, lookup);
-                                                        if (match) {
-                                                            meta = tslib_1.__assign(tslib_1.__assign({}, meta), { params: match.params });
-                                                            break;
-                                                        }
-                                                    }
-                                                }
-                                                compMetas.push(meta);
-                                            }
-                                        }
-                                    };
-                                    for (_i = 0, components_2 = components; _i < components_2.length; _i++) {
-                                        component = components_2[_i];
-                                        _loop_2(component);
-                                    }
-                                    renderData = (0, loader_react_1.convertBundlesToComponentRenderData)(bundles, compMetas);
-                                    renderData === null || renderData === void 0 ? void 0 : renderData.entryCompMetas.sort(function (meta1, meta2) {
-                                        // We sort the matched component metas by the number of path params, so
-                                        // if there are two pages `/products/foo` and `/products/[slug]`,
-                                        // the first one will have higher precedence.
-                                        return Array.from(Object.keys(meta1.params || {})).length -
-                                            Array.from(Object.keys(meta2.params || {})).length;
-                                    });
-                                    return [2 /*return*/, renderData];
-                            }
-                        });
-                    });
-                },
-            },
-            plasmicOptions: {
-                type: "JSON",
-                resolve: function () {
-                    return {
-                        projects: opts.projects,
-                        preview: opts.preview,
-                        host: opts.host,
-                    };
-                },
-            },
+var createResolvers = ({ createResolvers: createResolvers2 }, opts) => {
+  createResolvers2({
+    Query: {
+      plasmicComponents: {
+        type: "JSON",
+        args: {
+          componentNames: `[String]!`
         },
-    });
-};
-exports.createResolvers = createResolvers;
-var createSchemaCustomization = function (_a) {
-    var actions = _a.actions;
-    var createTypes = actions.createTypes;
-    createTypes(PLASMIC_DATA_TYPE);
-};
-exports.createSchemaCustomization = createSchemaCustomization;
-var createPages = function (_a, opts) {
-    var graphql = _a.graphql, actions = _a.actions, reporter = _a.reporter;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var defaultPlasmicPage, ignorePaths, createPage, deletePage, result, pages, _i, allPaths_1, path, _b, pages_1, page, path;
-        var _c;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    defaultPlasmicPage = opts.defaultPlasmicPage;
-                    ignorePaths = opts.ignorePaths || [];
-                    if (!defaultPlasmicPage) return [3 /*break*/, 2];
-                    reporter.info("[Plasmic Loader] - Creating pages");
-                    createPage = actions.createPage, deletePage = actions.deletePage;
-                    return [4 /*yield*/, graphql("\n      query {\n        allPlasmicData(filter: { isPage: { eq: true } }) {\n          nodes {\n            path\n          }\n        }\n      }\n    ")];
-                case 1:
-                    result = _d.sent();
-                    pages = (_c = result.data) === null || _c === void 0 ? void 0 : _c.allPlasmicData.nodes;
-                    if (!pages) {
-                        reporter.error("[Plasmic Loader] - GraphQL did not return pages");
-                        return [2 /*return*/];
+        resolve(_source, args, context, _info) {
+          return __async(this, null, function* () {
+            var _a2;
+            const { componentNames } = args;
+            const components = yield getAllNodes(
+              context.nodeModel,
+              PLASMIC_NODE_NAME
+            );
+            const bundles = [];
+            const compMetas = [];
+            for (const component of components) {
+              if (componentNames.includes(component.name) || componentNames.includes(component.displayName) || !!(component.path && componentNames.some(
+                (lookup) => (0, import_loader_react.matchesPagePath)(component.path, lookup)
+              ))) {
+                const bundle = (_a2 = component.renderData) == null ? void 0 : _a2.bundle;
+                if (bundle) {
+                  bundles.push(bundle);
+                  let meta = component;
+                  if (component.path) {
+                    for (const lookup of componentNames) {
+                      const match = (0, import_loader_react.matchesPagePath)(component.path, lookup);
+                      if (match) {
+                        meta = __spreadProps(__spreadValues({}, meta), { params: match.params });
+                        break;
+                      }
                     }
-                    for (_i = 0, allPaths_1 = allPaths; _i < allPaths_1.length; _i++) {
-                        path = allPaths_1[_i];
-                        deletePage({
-                            path: path,
-                            component: defaultPlasmicPage,
-                        });
-                        reporter.verbose("[Plasmic Loader] - Deleted page ".concat(path));
-                    }
-                    allPaths = [];
-                    for (_b = 0, pages_1 = pages; _b < pages_1.length; _b++) {
-                        page = pages_1[_b];
-                        path = page.path;
-                        if (ignorePaths.includes(path) || ignorePaths.includes(path + "/")) {
-                            continue;
-                        }
-                        allPaths.push(page.path);
-                        createPage({
-                            path: page.path,
-                            component: defaultPlasmicPage,
-                            context: {},
-                        });
-                        reporter.verbose("[Plasmic Loader] - Created page ".concat(page.path));
-                    }
-                    _d.label = 2;
-                case 2: return [2 /*return*/];
+                  }
+                  compMetas.push(meta);
+                }
+              }
             }
-        });
-    });
+            const renderData = (0, import_loader_react.convertBundlesToComponentRenderData)(
+              bundles,
+              compMetas
+            );
+            renderData == null ? void 0 : renderData.entryCompMetas.sort(
+              (meta1, meta2) => (
+                // We sort the matched component metas by the number of path params, so
+                // if there are two pages `/products/foo` and `/products/[slug]`,
+                // the first one will have higher precedence.
+                Array.from(Object.keys(meta1.params || {})).length - Array.from(Object.keys(meta2.params || {})).length
+              )
+            );
+            return renderData;
+          });
+        }
+      },
+      plasmicOptions: {
+        type: "JSON",
+        resolve() {
+          return {
+            projects: opts.projects,
+            preview: opts.preview,
+            host: opts.host
+          };
+        }
+      }
+    }
+  });
+};
+var createSchemaCustomization = ({ actions }) => {
+  const { createTypes } = actions;
+  createTypes(PLASMIC_DATA_TYPE);
 };
-exports.createPages = createPages;
-//# sourceMappingURL=gatsby-node.js.map
+var createPages = (_0, _1) => __async(void 0, [_0, _1], function* ({ graphql, actions, reporter }, opts) {
+  var _a;
+  const { defaultPlasmicPage } = opts;
+  const ignorePaths = opts.ignorePaths || [];
+  if (defaultPlasmicPage) {
+    reporter.info(`[Plasmic Loader] - Creating pages`);
+    const { createPage, deletePage } = actions;
+    const result = yield graphql(`
+      query {
+        allPlasmicData(filter: { isPage: { eq: true } }) {
+          nodes {
+            path
+          }
+        }
+      }
+    `);
+    const pages = (_a = result.data) == null ? void 0 : _a.allPlasmicData.nodes;
+    if (!pages) {
+      reporter.error(`[Plasmic Loader] - GraphQL did not return pages`);
+      return;
+    }
+    for (const path of allPaths) {
+      deletePage({
+        path,
+        component: defaultPlasmicPage
+      });
+      reporter.verbose(`[Plasmic Loader] - Deleted page ${path}`);
+    }
+    allPaths = [];
+    for (const page of pages) {
+      const path = page.path;
+      if (ignorePaths.includes(path) || ignorePaths.includes(path + "/")) {
+        continue;
+      }
+      allPaths.push(page.path);
+      createPage({
+        path: page.path,
+        component: defaultPlasmicPage,
+        context: {}
+      });
+      reporter.verbose(`[Plasmic Loader] - Created page ${page.path}`);
+    }
+  }
+});
+//# sourceMappingURL=gatsby-node.js.map