@uniformdev/canvas-next 19.10.0 → 19.11.0

package/dist/route/index.js

@@ -30,185 +30,381 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/route/index.ts
 var route_exports = {};
 __export(route_exports, {
+  getStaticPaths: () => getStaticPaths2,
   unstable_getServerSideProps: () => unstable_getServerSideProps,
-  unstable_logIssues: () => unstable_logIssues,
-  unstable_withUniformGetServerSideProps: () => unstable_withUniformGetServerSideProps
+  unstable_getStaticProps: () => unstable_getStaticProps,
+  unstable_withUniformGetServerSideProps: () => unstable_withUniformGetServerSideProps,
+  unstable_withUniformGetStaticProps: () => unstable_withUniformGetStaticProps,
+  withUniformGetStaticPaths: () => withUniformGetStaticPaths
 });
 module.exports = __toCommonJS(route_exports);
 
-// src/route/withUniformGetServerSideProps.ts
+// src/project-map/withUniformGetServerSideProps.ts
 var import_canvas = require("@uniformdev/canvas");
-var import_chalk3 = __toESM(require("chalk"));
-
-// src/route/defaultHandleComposition.ts
-var import_chalk2 = __toESM(require("chalk"));
-
-// src/route/logIssues.ts
-var import_chalk = __toESM(require("chalk"));
-function unstable_logIssues(prefix, issues, colour) {
-  colour = colour != null ? colour : "red";
-  const reversedIssues = [...issues].reverse();
-  console.error(
-    `${import_chalk.default[colour](prefix)}
-${reversedIssues.map(
-      (issue) => `${import_chalk.default[colour](">")} ${import_chalk.default.italic.gray(indent(issue.type.toUpperCase(), 7))} ${renderIssue(
-        issue
-      )}`
-    ).join("\n")}`
-  );
-}
-function renderIssue(issue) {
-  var _a;
-  let path;
-  let type;
-  let message = issue.message;
-  let detail;
-  if (issue.type !== "config") {
-    path = issue.componentPath;
-    type = issue.componentType;
-    message = issue.message;
-  }
-  if (issue.type === "binding") {
-    detail = `Binding expression: ${(_a = issue.expression) == null ? void 0 : _a.pointer}`;
-  } else if (issue.type === "data") {
-    detail = `Data resource name: ${issue.dataName}, data type: ${issue.dataType}`;
-  }
-  if (issue.type === "input") {
-    detail = issue.inputName;
-  }
-  let result = `${import_chalk.default.white(blockify(message))}`;
-  if (detail) {
-    result += `
-${indent(" ", 10)}${import_chalk.default.gray(`${detail}`)}`;
-  }
-  if (path && type) {
-    result += `
-${indent(" ", 10)}${import_chalk.default.gray(`Occurred on component ${type} at slot path ${path}`)}`;
-  }
-  return result;
-}
-function indent(str, len) {
-  const indent2 = len != null ? len : 10;
-  return str.padStart(indent2);
-}
-function blockify(str, len) {
-  const indentSize = len != null ? len : 10;
-  return str.split("\n").map((line, index) => index === 0 ? line : `${indent(" ", indentSize)}${line}`).join("\n");
-}
-
-// src/route/defaultHandleComposition.ts
-function defaultHandleComposition(matched) {
-  var _a, _b;
-  const resErrors = (_a = matched.compositionApiResponse.errors) != null ? _a : [];
-  const resWarnings = (_b = matched.compositionApiResponse.warnings) != null ? _b : [];
-  const colour = resErrors.length > 0 ? "red" : resWarnings.length > 0 ? "yellow" : "green";
-  console.log(`[canvas-next] ${import_chalk2.default[colour]("matched")} ${matched.matchedRoute}`, matched.type);
-  if (matched.dynamicInputs) {
-    const entries = Object.entries(matched.dynamicInputs);
-    if (entries.length > 0) {
-      console.log(
-        `  ${import_chalk2.default.gray("Matched dynamic inputs:\n   ")}`,
-        entries.map(([k, v]) => `${k}: ${v}`).join("\n    ")
-      );
+var withUniformGetServerSideProps = (options) => {
+  const canvasClient = (options == null ? void 0 : options.client) || new import_canvas.CanvasClient({
+    apiKey: process.env.UNIFORM_API_KEY,
+    projectId: process.env.UNIFORM_PROJECT_ID,
+    apiHost: process.env.UNIFORM_CLI_BASE_URL,
+    edgeApiHost: process.env.UNIFORM_CLI_BASE_EDGE_URL
+  });
+  return async function wrappedGetServerSideProps(context) {
+    var _a, _b;
+    const projectMapId = (_a = options == null ? void 0 : options.projectMapId) != null ? _a : process.env.UNIFORM_PROJECT_MAP_ID;
+    const { preview, previewData } = context;
+    let composition = void 0;
+    let nodePath = (options == null ? void 0 : options.prefix) ? context.resolvedUrl.replace(new RegExp(`^${options.prefix}`), "") : context.resolvedUrl;
+    if (options == null ? void 0 : options.modifyPath) {
+      nodePath = options.modifyPath(nodePath, context);
     }
-  }
-  if (resErrors.length > 0) {
-    unstable_logIssues(
-      `[canvas-next] ${matched.matchedRoute} composition data error${resErrors.length === 1 ? "" : "s"}; some content may be missing`,
-      resErrors,
-      "red"
-    );
-  }
-  if (resWarnings.length > 0) {
-    unstable_logIssues(
-      `[canvas-next] ${matched.matchedRoute} composition data warning${resWarnings.length === 1 ? "" : "s"}; some content may be missing`,
-      resWarnings,
-      "yellow"
-    );
-  }
-  if (matched.compositionApiResponse.diagnostics) {
-    console.log(`[canvas-next] ${import_chalk2.default.green("Route diagnostics are enabled. Diagnostic data:")}`);
-    console.log(JSON.stringify(matched.compositionApiResponse.diagnostics, null, 2));
-  }
-  return matched.compositionApiResponse.composition;
-}
-
-// src/route/defaultHandleRedirect.ts
-var import_redirect = require("@uniformdev/redirect");
-function defaultHandleRedirect(matched, requestUrl) {
-  return {
-    redirect: {
-      destination: import_redirect.RedirectClient.getTargetVariableExpandedUrl(requestUrl, matched.redirect),
-      statusCode: matched.redirect.targetStatusCode
+    if (previewData == null ? void 0 : previewData.isUniformContextualEditing) {
+      composition = { ...import_canvas.EMPTY_COMPOSITION, _id: (_b = previewData.compositionId) != null ? _b : import_canvas.EMPTY_COMPOSITION._id };
+    } else {
+      try {
+        const time = Date.now();
+        const response = await canvasClient.getCompositionByNodePath({
+          ...options == null ? void 0 : options.requestOptions,
+          projectMapId,
+          projectMapNodePath: nodePath,
+          state: preview || (options == null ? void 0 : options.preview) ? import_canvas.CANVAS_DRAFT_STATE : import_canvas.CANVAS_PUBLISHED_STATE
+        });
+        const duration = Date.now() - time;
+        composition = response.composition;
+        if (!(options == null ? void 0 : options.silent)) {
+          (0, import_canvas.logCompositionResponse)(response, duration);
+        }
+      } catch (e) {
+        console.error("[canvas-next] Failed to fetch composition", e);
+        return {
+          notFound: true
+        };
+      }
     }
+    const ret = (options == null ? void 0 : options.callback) ? await options.callback(context, composition) : { props: {} };
+    if (Object.hasOwn(ret, "props")) {
+      const casted = ret;
+      casted.props["data"] = composition;
+    }
+    return ret;
   };
-}
+};
 
-// src/route/withUniformGetServerSideProps.ts
-var unstable_withUniformGetServerSideProps = (options) => {
-  var _a, _b, _c, _d;
-  const handleNotFound = (_a = options == null ? void 0 : options.handleNotFound) != null ? _a : () => ({ notFound: true });
-  const handleComposition = (_b = options == null ? void 0 : options.handleComposition) != null ? _b : defaultHandleComposition;
-  const handleRedirect = (_c = options == null ? void 0 : options.handleRedirect) != null ? _c : defaultHandleRedirect;
-  const handleModifyPath = (_d = options == null ? void 0 : options.modifyPath) != null ? _d : (path) => decodeURI(path);
-  return async function wrappedGetServerSideProps(context) {
-    var _a2, _b2;
-    const projectMapId = (_a2 = options == null ? void 0 : options.projectMapId) != null ? _a2 : process.env.UNIFORM_PROJECT_MAP_ID;
-    const routeClient = (options == null ? void 0 : options.client) || new import_canvas.unstable_RouteClient({
+// src/project-map/withUniformGetStaticPaths.ts
+var import_canvas2 = require("@uniformdev/canvas");
+var import_project_map = require("@uniformdev/project-map");
+var withUniformGetStaticPaths = (options) => {
+  return async function wrappedGetStaticPaths() {
+    var _a, _b;
+    const projectMapId = (_a = options == null ? void 0 : options.projectMapId) != null ? _a : process.env.UNIFORM_PROJECT_MAP_ID;
+    const projectMapClient = (_b = options == null ? void 0 : options.client) != null ? _b : new import_project_map.ProjectMapClient({
       apiKey: process.env.UNIFORM_API_KEY,
       projectId: process.env.UNIFORM_PROJECT_ID,
-      edgeApiHost: process.env.UNIFORM_CLI_BASE_EDGE_URL
+      apiHost: process.env.UNIFORM_CLI_BASE_URL
+    });
+    const response = await projectMapClient.getNodes({
+      ...options == null ? void 0 : options.requestOptions,
+      path: options == null ? void 0 : options.rootPath,
+      projectMapId,
+      state: (options == null ? void 0 : options.preview) ? import_canvas2.CANVAS_DRAFT_STATE : import_canvas2.CANVAS_PUBLISHED_STATE
     });
-    const { previewData } = context;
+    const nodes = (options == null ? void 0 : options.callback) ? await options.callback(response.nodes) : response.nodes;
+    const paths = nodes == null ? void 0 : nodes.filter((node) => Boolean(node.compositionId)).map((node) => {
+      var _a2;
+      return `${(_a2 = options == null ? void 0 : options.prefix) != null ? _a2 : ""}${node.path}`;
+    });
+    return {
+      paths,
+      fallback: true
+    };
+  };
+};
+
+// src/project-map/withUniformGetStaticProps.ts
+var import_canvas3 = require("@uniformdev/canvas");
+
+// src/helpers/resolveSlugFromParams.ts
+var resolveSlugFromParams = ({
+  param = "slug",
+  params
+}) => {
+  const slug = (params == null ? void 0 : params[param]) || "";
+  const slugString = Array.isArray(slug) ? slug.join("/") : slug;
+  return `/${slugString}`;
+};
+
+// src/project-map/withUniformGetStaticProps.ts
+var withUniformGetStaticProps = (options) => {
+  var _a;
+  const canvasClient = (_a = options == null ? void 0 : options.client) != null ? _a : new import_canvas3.CanvasClient({
+    apiKey: process.env.UNIFORM_API_KEY,
+    projectId: process.env.UNIFORM_PROJECT_ID,
+    apiHost: process.env.UNIFORM_CLI_BASE_URL,
+    edgeApiHost: process.env.UNIFORM_CLI_BASE_EDGE_URL
+  });
+  return async function wrappedGetStaticProps(context) {
+    var _a2, _b;
+    const projectMapId = (_a2 = options == null ? void 0 : options.projectMapId) != null ? _a2 : process.env.UNIFORM_PROJECT_MAP_ID;
+    let pathString = resolveSlugFromParams({
+      param: options == null ? void 0 : options.param,
+      params: context == null ? void 0 : context.params
+    });
+    if (options == null ? void 0 : options.modifyPath) {
+      pathString = options.modifyPath(pathString, context);
+    }
+    const { preview, previewData } = context;
     let composition = void 0;
-    let nodePath = (options == null ? void 0 : options.prefix) ? context.resolvedUrl.replace(new RegExp(`^${options.prefix}`), "") : context.resolvedUrl;
-    nodePath = handleModifyPath(nodePath, context);
     if (previewData == null ? void 0 : previewData.isUniformContextualEditing) {
-      composition = { ...import_canvas.EMPTY_COMPOSITION, _id: (_b2 = previewData.compositionId) != null ? _b2 : import_canvas.EMPTY_COMPOSITION._id };
+      composition = { ...import_canvas3.EMPTY_COMPOSITION, _id: (_b = previewData.compositionId) != null ? _b : import_canvas3.EMPTY_COMPOSITION._id };
     } else {
       try {
-        console.log("[canvas-next] get route", nodePath);
-        const response = await routeClient.getRoute({
+        const time = Date.now();
+        const response = await canvasClient.getCompositionByNodePath({
           ...options == null ? void 0 : options.requestOptions,
           projectMapId,
+          projectMapNodePath: pathString,
+          state: preview || (options == null ? void 0 : options.preview) ? import_canvas3.CANVAS_DRAFT_STATE : import_canvas3.CANVAS_PUBLISHED_STATE
+        });
+        const duration = Date.now() - time;
+        composition = response.composition;
+        if (!(options == null ? void 0 : options.silent)) {
+          (0, import_canvas3.logCompositionResponse)(response, duration);
+        }
+      } catch (e) {
+        console.error("[canvas-next] Failed to fetch composition", e);
+        return {
+          notFound: true
+        };
+      }
+    }
+    const ret = options.callback ? await options.callback(context, composition) : { props: {} };
+    if (composition && Object.hasOwn(ret, "props")) {
+      const casted = ret;
+      casted.props["data"] = composition;
+    }
+    return ret;
+  };
+};
+
+// src/project-map/index.ts
+var getServerSideProps = withUniformGetServerSideProps();
+var getStaticProps = withUniformGetStaticProps({ param: "path" });
+var getStaticPaths = withUniformGetStaticPaths();
+
+// src/route/withUniformGetServerSideProps.ts
+var import_redirect = require("@uniformdev/redirect");
+
+// src/route/createRouteFetcher.ts
+var import_canvas4 = require("@uniformdev/canvas");
+var import_ansi_colors = __toESM(require("ansi-colors"));
+var { red } = import_ansi_colors.default;
+function createRouteFetcher(options) {
+  const {
+    handleNotFound,
+    handleComposition,
+    handleRedirect,
+    defaultHandleComposition,
+    defaultHandleNotFound,
+    defaultHandleRedirect,
+    modifyPath,
+    projectMapId = process.env.UNIFORM_PROJECT_MAP_ID,
+    client,
+    prefix,
+    requestOptions,
+    silent,
+    parseContext
+  } = options;
+  const routeClient = client || new import_canvas4.unstable_RouteClient({
+    apiKey: process.env.UNIFORM_API_KEY,
+    projectId: process.env.UNIFORM_PROJECT_ID,
+    edgeApiHost: process.env.UNIFORM_CLI_BASE_EDGE_URL
+  });
+  const handleModifyPath = modifyPath != null ? modifyPath : (path) => decodeURI(path);
+  return async function fetcher(context) {
+    const { contextualEditingCompositionId, resolvedUrl } = parseContext(context);
+    let nodePath = prefix ? resolvedUrl.replace(new RegExp(`^${prefix}`), "") : resolvedUrl;
+    nodePath = handleModifyPath(nodePath, context);
+    const invokeRedirectResult = (redirect, duration) => (handleRedirect != null ? handleRedirect : defaultHandleRedirect)(
+      nodePath,
+      redirect,
+      context,
+      (response) => defaultHandleRedirect(
+        nodePath,
+        response,
+        context,
+        () => {
+          throw new Error();
+        },
+        duration
+      ),
+      duration
+    );
+    const invokeNotFoundResult = (response, duration) => (handleNotFound != null ? handleNotFound : defaultHandleNotFound)(
+      response,
+      context,
+      (response2) => defaultHandleNotFound(
+        response2,
+        context,
+        () => {
+          throw new Error();
+        },
+        duration
+      ),
+      duration
+    );
+    const invokeCompositionResult = (response, duration) => (handleComposition != null ? handleComposition : defaultHandleComposition)(
+      response,
+      context,
+      (response2) => defaultHandleComposition(
+        response2,
+        context,
+        () => {
+          throw new Error();
+        },
+        duration
+      ),
+      duration
+    );
+    if (contextualEditingCompositionId) {
+      const previewEmptyComposition = await invokeCompositionResult(
+        {
+          type: "composition",
+          matchedRoute: "contextual-editing",
+          compositionApiResponse: {
+            composition: {
+              ...import_canvas4.EMPTY_COMPOSITION,
+              _id: contextualEditingCompositionId != null ? contextualEditingCompositionId : import_canvas4.EMPTY_COMPOSITION._id
+            }
+          }
+        },
+        0
+      );
+      return previewEmptyComposition;
+    } else {
+      try {
+        if (!silent) {
+          console.log("Fetch route", nodePath);
+        }
+        const time = Date.now();
+        const response = await routeClient.getRoute({
+          ...requestOptions,
+          projectMapId,
           path: nodePath
         });
+        const duration = Date.now() - time;
+        if (!silent) {
+          (0, import_canvas4.logRouteResponse)(response, duration);
+        }
         if (response.type === "redirect") {
-          return handleRedirect(response, nodePath, context, defaultHandleRedirect);
+          return invokeRedirectResult(response, duration);
         }
         if (response.type === "notFound") {
-          return handleNotFound(response, context);
+          return invokeNotFoundResult(response, duration);
         }
-        const handleResult = handleComposition(response, context, defaultHandleComposition);
+        const handleResult = await invokeCompositionResult(response, duration);
         if (!handleResult) {
-          return { notFound: true };
+          return invokeNotFoundResult({ type: "notFound" }, duration);
         }
-        composition = handleResult;
+        return handleResult;
       } catch (e) {
-        console.error(import_chalk3.default.red("[canvas-next] Failed to fetch composition"), e);
-        if (e instanceof import_canvas.ApiClientError) {
+        console.error(red("Failed to fetch route"), e);
+        if (e instanceof import_canvas4.ApiClientError) {
           if (e.statusCode === 404) {
-            return { notFound: true };
+            return invokeNotFoundResult({ type: "notFound" }, 0);
           }
-          throw new Error(`Failed to fetch composition. See server logs for details.`);
+          throw new Error(`Failed to fetch route. See preceding server logs for details.`);
         }
         throw e;
       }
     }
-    const ret = (options == null ? void 0 : options.callback) ? await options.callback(context, composition) : { props: {} };
-    if (Object.hasOwn(ret, "props")) {
-      const casted = ret;
-      casted.props["data"] = composition;
+  };
+}
+
+// src/route/withUniformGetServerSideProps.ts
+var unstable_withUniformGetServerSideProps = (options) => {
+  const defaultHandleRedirect = (requestUrl, matched) => {
+    return {
+      redirect: {
+        destination: import_redirect.RedirectClient.getTargetVariableExpandedUrl(requestUrl, matched.redirect),
+        statusCode: matched.redirect.targetStatusCode
+      }
+    };
+  };
+  const defaultHandleNotFound = () => ({
+    notFound: true
+  });
+  const defaultHandleComposition = async (matched) => {
+    return {
+      props: {
+        data: matched.compositionApiResponse.composition
+      }
+    };
+  };
+  const routeFetcher = createRouteFetcher({
+    ...options,
+    defaultHandleComposition,
+    defaultHandleNotFound,
+    defaultHandleRedirect,
+    parseContext(context) {
+      var _a;
+      return {
+        contextualEditingCompositionId: (_a = context.previewData) == null ? void 0 : _a.compositionId,
+        resolvedUrl: context.resolvedUrl
+      };
     }
-    return ret;
+  });
+  return routeFetcher;
+};
+
+// src/route/withUniformGetStaticProps.ts
+var import_redirect2 = require("@uniformdev/redirect");
+var unstable_withUniformGetStaticProps = (options) => {
+  const defaultHandleRedirect = (requestUrl, matched) => {
+    return {
+      redirect: {
+        destination: import_redirect2.RedirectClient.getTargetVariableExpandedUrl(requestUrl, matched.redirect),
+        statusCode: matched.redirect.targetStatusCode
+      }
+    };
   };
+  const defaultHandleNotFound = () => ({
+    notFound: true
+  });
+  const defaultHandleComposition = async (matched) => {
+    return {
+      props: {
+        data: matched.compositionApiResponse.composition
+      }
+    };
+  };
+  const routeFetcher = createRouteFetcher({
+    ...options,
+    defaultHandleComposition,
+    defaultHandleNotFound,
+    defaultHandleRedirect,
+    parseContext(context) {
+      var _a, _b;
+      return {
+        contextualEditingCompositionId: (_a = context.previewData) == null ? void 0 : _a.compositionId,
+        resolvedUrl: resolveSlugFromParams({
+          params: context.params,
+          param: (_b = options == null ? void 0 : options.param) != null ? _b : "route"
+        })
+      };
+    }
+  });
+  return routeFetcher;
 };
 
 // src/route/index.ts
 var unstable_getServerSideProps = unstable_withUniformGetServerSideProps();
+var unstable_getStaticProps = unstable_withUniformGetStaticProps();
+var getStaticPaths2 = withUniformGetStaticPaths();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getStaticPaths,
   unstable_getServerSideProps,
-  unstable_logIssues,
-  unstable_withUniformGetServerSideProps
+  unstable_getStaticProps,
+  unstable_withUniformGetServerSideProps,
+  unstable_withUniformGetStaticProps,
+  withUniformGetStaticPaths
 });