prismic-ts-codegen 0.1.5 → 0.1.7

package/bin/cli.mjs

@@ -1,1342 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync, existsSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
-import meow from 'meow';
-import { stripIndent } from 'common-tags';
-import { Project, ModuleDeclarationKind } from 'ts-morph';
-import { CustomTypeModelSliceType, CustomTypeModelFieldType, CustomTypeModelLinkSelectType } from '@prismicio/types';
-import { pascalCase as pascalCase$1, pascalCaseTransformMerge } from 'pascal-case';
-import Joi from 'joi';
-import * as prismic from '@prismicio/client';
-import fetch from 'node-fetch';
-import fg from 'fast-glob';
-import * as prismicCT from '@prismicio/custom-types-client';
-import _jiti from 'jiti';
-
-const BLANK_LINE_IDENTIFIER = "// ___BLANK_LINE_TO_BE_REPLACED___";
-const CUSTOM_TYPES_DOCUMENTATION_URL = "https://prismic.io/docs/core-concepts/custom-types";
-const SHARED_SLICES_DOCUMENTATION_URL = "https://prismic.io/docs/core-concepts/reusing-slices";
-const FIELD_DOCUMENTATION_URLS = {
-  UID: "https://prismic.io/docs/core-concepts/uid",
-  Boolean: "https://prismic.io/docs/core-concepts/boolean",
-  Color: "https://prismic.io/docs/core-concepts/color",
-  Date: "https://prismic.io/docs/core-concepts/date",
-  Timestamp: "https://prismic.io/docs/core-concepts/timestamp",
-  Number: "https://prismic.io/docs/core-concepts/number",
-  Text: "https://prismic.io/docs/core-concepts/key-text",
-  Select: "https://prismic.io/docs/core-concepts/select",
-  StructuredText: "https://prismic.io/docs/core-concepts/rich-text-title",
-  Image: "https://prismic.io/docs/core-concepts/image",
-  Link: "https://prismic.io/docs/core-concepts/link-content-relationship",
-  Embed: "https://prismic.io/docs/core-concepts/embed",
-  GeoPoint: "https://prismic.io/docs/core-concepts/geopoint",
-  Group: "https://prismic.io/docs/core-concepts/group",
-  IntegrationFields: "https://prismic.io/docs/core-concepts/integration-fields",
-  Slices: "https://prismic.io/docs/core-concepts/slices",
-  LegacySlices: "https://prismic.io/docs/core-concepts/slices"
-};
-
-const isCustomTypeModelField = (model) => {
-  return typeof model === "object" && model !== null && "type" in model;
-};
-
-const hasOwnProperty = (obj, prop) => {
-  return obj.hasOwnProperty(prop);
-};
-
-const isCustomTypeModelSlice = (model) => {
-  return typeof model === "object" && model !== null && hasOwnProperty(model, "type") && model.type === CustomTypeModelSliceType.Slice;
-};
-
-const isSharedSliceModel$1 = (model) => {
-  return typeof model === "object" && model !== null && hasOwnProperty(model, "type") && model.type === CustomTypeModelSliceType.SharedSlice;
-};
-
-const getAPIIDPath = (config) => {
-  return config.path.map((element, i) => {
-    if (isCustomTypeModelField(element.model) && (element.model.type === CustomTypeModelFieldType.Group || element.model.type === CustomTypeModelFieldType.Slices)) {
-      return `${element.id}[]`;
-    } else {
-      if (element.id === "items") {
-        const previousElement = config.path[i - 1];
-        if (isCustomTypeModelSlice(previousElement.model) || isSharedSliceModel$1(previousElement.model)) {
-          return `${element.id}[]`;
-        }
-      }
-      return element.id;
-    }
-  }).join(".");
-};
-
-const getFieldDocumentationURL = (config) => {
-  return FIELD_DOCUMENTATION_URLS[config.model.type];
-};
-
-const isCustomTypeModel$1 = (model) => {
-  return typeof model === "object" && model !== null && "json" in model;
-};
-
-const getHumanReadableModelName = (config) => {
-  if (isCustomTypeModel$1(config.model)) {
-    return config.model.label || config.model.id;
-  } else if (isSharedSliceModel$1(config.model)) {
-    return config.model.name;
-  } else if (isCustomTypeModelField(config.model)) {
-    if (config.model.config && "label" in config.model.config) {
-      return config.model.config.label || config.id;
-    } else if (config.model.config && "fieldset" in config.model) {
-      return config.model.fieldset || config.id;
-    }
-  } else if (isCustomTypeModelSlice(config.model)) {
-    return config.model.fieldset || config.id;
-  }
-  return `\`${config.id}\``;
-};
-
-const getHumanReadableFieldPath = (config) => {
-  return config.path.map((element) => {
-    if (element.label) {
-      return element.label;
-    } else if (element.model) {
-      return getHumanReadableModelName({
-        id: element.id,
-        model: element.model
-      });
-    } else {
-      return element.id;
-    }
-  }).join(" \u2192 ");
-};
-
-const getHumanReadableFieldType = (config) => {
-  switch (config.model.type) {
-    case "StructuredText": {
-      const isTitleField = config.model.config && "single" in config.model.config && config.model.config.single && config.model.config.single.split(",").every((blockType) => /heading/.test(blockType));
-      return isTitleField ? "Title" : "Rich Text";
-    }
-    case "IntegrationFields": {
-      const catalog = config.model.config?.catalog;
-      return `Integration Fields (Catalog: ${catalog ? `\`${catalog}\`` : "*unknown*"})`;
-    }
-    case "Link": {
-      switch (config.model.config?.select) {
-        case CustomTypeModelLinkSelectType.Document: {
-          return "Content Relationship";
-        }
-        case CustomTypeModelLinkSelectType.Media: {
-          return "Link to Media";
-        }
-        default: {
-          return "Link";
-        }
-      }
-    }
-    case "Slices": {
-      return "Slice Zone";
-    }
-    default: {
-      return config.model.type;
-    }
-  }
-};
-
-const writeFieldDocsDescription = (config) => {
-  if (config.description) {
-    config.writer.writeLine(config.description);
-  }
-  config.writer.blankLineIfLastNot();
-  if (config.fieldType) {
-    config.writer.writeLine(`- **Field Type**: ${config.fieldType}`);
-  }
-  if (config.placeholder) {
-    config.writer.writeLine(`- **Placeholder**: ${config.placeholder}`);
-  }
-  if (config.defaultValue !== void 0) {
-    const stringifiedDefaultValue = typeof config.defaultValue === "boolean" ? `${config.defaultValue}` : config.defaultValue;
-    config.writer.writeLine(`- **Default Value**: ${stringifiedDefaultValue}`);
-  }
-  if (config.apiIDPath) {
-    config.writer.writeLine(`- **API ID Path**: ${config.apiIDPath}`);
-  }
-  if (config.tabName) {
-    config.writer.writeLine(`- **Tab**: ${config.tabName}`);
-  }
-  if (config.documentationURL) {
-    config.writer.writeLine(`- **Documentation**: ${config.documentationURL}`);
-  }
-};
-
-const buildFieldDocs = (config) => {
-  return [
-    {
-      description: (writer) => {
-        const name = getHumanReadableModelName({
-          id: config.id,
-          model: config.model
-        });
-        const humanReadablePath = getHumanReadableFieldPath({
-          path: config.path
-        });
-        const fieldType = getHumanReadableFieldType({
-          model: config.model
-        });
-        const placeholder = config.model.config && "placeholder" in config.model.config && config.model.config.placeholder ? config.model.config.placeholder : `*None*`;
-        const defaultValue = config.model.config && "default_value" in config.model.config ? config.model.config.default_value : void 0;
-        const apiIDPath = getAPIIDPath({
-          path: [...config.path, { id: config.id, model: config.model }]
-        });
-        writeFieldDocsDescription({
-          writer,
-          description: `${name} field in *${humanReadablePath}*`,
-          fieldType,
-          placeholder,
-          defaultValue,
-          apiIDPath,
-          tabName: config.tabName,
-          documentationURL: getFieldDocumentationURL({ model: config.model })
-        });
-      }
-    }
-  ];
-};
-
-const pascalCase = (input) => pascalCase$1(input, {
-  transform: pascalCaseTransformMerge
-});
-
-const buildSharedSliceInterfaceNamePart = (config) => {
-  return pascalCase(`${config.id} Slice`);
-};
-
-const buildTypeName = (...parts) => {
-  let name = pascalCase(parts.filter(Boolean).join(" "));
-  if (/^[0-9]/.test(name) ? "_" : "") {
-    name = `_${name}`;
-  }
-  return name;
-};
-
-const addInterfacePropertyForField = (config) => {
-  switch (config.model.type) {
-    case "UID": {
-      break;
-    }
-    case "Boolean": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.BooleanField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Color": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.ColorField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Date": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.DateField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Embed": {
-      const providerTypes = [];
-      if (config.fieldConfigs.embed?.providerTypes) {
-        for (const providerType in config.fieldConfigs.embed?.providerTypes) {
-          const configuredProviderType = config.fieldConfigs.embed?.providerTypes[providerType];
-          providerTypes.push(
-            `({ provider_name: "${providerType}" } & ${configuredProviderType})`
-          );
-        }
-      }
-      config.interface.addProperty({
-        name: config.id,
-        type: providerTypes.length > 0 ? `prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra & (${providerTypes.join(
-          " | "
-        )})>` : "prismicT.EmbedField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "GeoPoint": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.GeoPointField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Image": {
-      if (config.model.config?.thumbnails && config.model.config.thumbnails.length > 0) {
-        const thumbnailNames = config.model.config.thumbnails.map((thumbnail) => `"${thumbnail.name}"`).join(" | ");
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.ImageField<${thumbnailNames}>`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.ImageField<never>",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "IntegrationFields": {
-      const catalogType = config.model.config?.catalog ? config.fieldConfigs.integrationFields?.catalogTypes?.[config.model.config.catalog] : void 0;
-      config.interface.addProperty({
-        name: config.id,
-        type: catalogType ? `prismicT.IntegrationFields<${catalogType}>` : "prismicT.IntegrationFields",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Link": {
-      switch (config.model.config?.select) {
-        case CustomTypeModelLinkSelectType.Document: {
-          config.model.config;
-          config.interface.addProperty({
-            name: config.id,
-            type: "customtypes" in config.model.config && config.model.config.customtypes && config.model.config.customtypes.length > 0 ? `prismicT.RelationField<${config.model.config.customtypes.map((type) => `"${type}"`).join(" | ")}>` : "prismicT.RelationField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-          break;
-        }
-        case CustomTypeModelLinkSelectType.Media: {
-          config.interface.addProperty({
-            name: config.id,
-            type: "prismicT.LinkToMediaField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-          break;
-        }
-        default: {
-          config.interface.addProperty({
-            name: config.id,
-            type: "prismicT.LinkField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-        }
-      }
-      break;
-    }
-    case "Number": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.NumberField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "StructuredText": {
-      const isTitleField = config.model.config && "single" in config.model.config && config.model.config.single && config.model.config.single.split(",").every((blockType) => /heading/.test(blockType));
-      if (isTitleField) {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.TitleField",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.RichTextField",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "Select": {
-      const options = config.model.config?.options?.map((option) => `"${option}"`).join(" | ");
-      const hasDefault = Boolean(config.model.config?.default_value);
-      if (hasDefault) {
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.SelectField<${options || "string"}, "filled">`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.SelectField<${options}>`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "Text": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.KeyTextField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Timestamp": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.TimestampField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Group": {
-      const itemInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          config.path[0].id,
-          "Document",
-          "Data",
-          config.id,
-          "Item"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  }
-                ]
-              });
-              writer.writeLine(`Item in ${humanReadablePath}`);
-            }
-          }
-        ],
-        isExported: true
-      });
-      if (config.model.config?.fields) {
-        addInterfacePropertiesForFields({
-          interface: itemInterface,
-          sourceFile: config.sourceFile,
-          fields: config.model.config.fields,
-          path: [
-            ...config.path,
-            {
-              id: config.id,
-              model: config.model
-            }
-          ],
-          fieldConfigs: config.fieldConfigs
-        });
-      }
-      config.interface.addProperty({
-        name: config.id,
-        type: `prismicT.GroupField<Simplify<${itemInterface.getName()}>>`,
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Slices": {
-      const choiceInterfaceNames = [];
-      if (config.model.config?.choices) {
-        for (const choiceId in config.model.config.choices) {
-          const choice = config.model.config.choices[choiceId];
-          if (choice.type === CustomTypeModelSliceType.SharedSlice) {
-            choiceInterfaceNames.push(
-              buildSharedSliceInterfaceNamePart({ id: choiceId })
-            );
-          } else if (choice.type === CustomTypeModelSliceType.Slice) {
-            let primaryInterface;
-            if (choice["non-repeat"] && Object.keys(choice["non-repeat"]).length > 0) {
-              primaryInterface = config.sourceFile.addInterface({
-                name: buildTypeName(
-                  config.path[0].id,
-                  "Document",
-                  "Data",
-                  config.id,
-                  choiceId,
-                  "Slice",
-                  "Primary"
-                ),
-                docs: [
-                  {
-                    description: (writer) => {
-                      const humanReadablePath = getHumanReadableFieldPath({
-                        path: [
-                          ...config.path,
-                          {
-                            id: config.id,
-                            model: config.model
-                          },
-                          {
-                            id: choiceId,
-                            model: choice
-                          },
-                          {
-                            id: "primary",
-                            label: "Primary"
-                          }
-                        ]
-                      });
-                      writer.writeLine(
-                        `Primary content in ${humanReadablePath}`
-                      );
-                    }
-                  }
-                ]
-              });
-              addInterfacePropertiesForFields({
-                interface: primaryInterface,
-                sourceFile: config.sourceFile,
-                fields: choice["non-repeat"],
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  },
-                  {
-                    id: choiceId,
-                    model: choice
-                  },
-                  {
-                    id: "primary",
-                    label: "Primary"
-                  }
-                ],
-                fieldConfigs: config.fieldConfigs
-              });
-            }
-            let itemInterface;
-            if (choice.repeat && Object.keys(choice.repeat).length > 0) {
-              itemInterface = config.sourceFile.addInterface({
-                name: buildTypeName(
-                  config.path[0].id,
-                  "Document",
-                  "Data",
-                  config.id,
-                  choiceId,
-                  "Slice",
-                  "Item"
-                ),
-                docs: [
-                  {
-                    description: (writer) => {
-                      const humanReadablePath = getHumanReadableFieldPath({
-                        path: [
-                          ...config.path,
-                          {
-                            id: config.id,
-                            model: config.model
-                          },
-                          {
-                            id: choiceId,
-                            model: choice
-                          },
-                          {
-                            id: "items",
-                            label: "Items"
-                          }
-                        ]
-                      });
-                      writer.writeLine(`Item in ${humanReadablePath}`);
-                    }
-                  }
-                ],
-                isExported: true
-              });
-              addInterfacePropertiesForFields({
-                interface: itemInterface,
-                sourceFile: config.sourceFile,
-                fields: choice.repeat,
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  },
-                  {
-                    id: choiceId,
-                    model: choice
-                  },
-                  {
-                    id: "items",
-                    label: "Items"
-                  }
-                ],
-                fieldConfigs: config.fieldConfigs
-              });
-            }
-            const sliceType = config.sourceFile.addTypeAlias({
-              name: buildTypeName(
-                config.path[0].id,
-                "Document",
-                "Data",
-                config.id,
-                choiceId,
-                "Slice"
-              ),
-              type: `prismicT.Slice<"${choiceId}", ${primaryInterface ? `Simplify<${primaryInterface.getName()}>` : "Record<string, never>"}, ${itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"}>`,
-              isExported: true
-            });
-            choiceInterfaceNames.push(sliceType.getName());
-          }
-        }
-      }
-      const slicesType = config.sourceFile.addTypeAlias({
-        name: buildTypeName(
-          config.path[0].id,
-          "Document",
-          "Data",
-          config.id,
-          "Slice"
-        ),
-        type: choiceInterfaceNames.length > 0 ? choiceInterfaceNames.join(" | ") : "never",
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  }
-                ]
-              });
-              writer.writeLine(`Slice for *${humanReadablePath}*`);
-            }
-          }
-        ]
-      });
-      config.interface.addProperty({
-        name: config.id,
-        type: `prismicT.SliceZone<${slicesType.getName()}>`,
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    default: {
-      config.interface.addProperty({
-        name: config.id,
-        type: "unknown",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-    }
-  }
-};
-const addInterfacePropertiesForFields = (config) => {
-  for (const name in config.fields) {
-    addInterfacePropertyForField({
-      ...config,
-      id: name.includes("-") || /^[0-9]/.test(name) ? `"${name}"` : name,
-      model: config.fields[name],
-      tabName: config.tabName
-    });
-  }
-};
-
-const collectCustomTypeFields = (model) => {
-  return Object.assign({}, ...Object.values(model.json));
-};
-const addTypeAliasForCustomType = ({
-  model,
-  sourceFile,
-  localeIDs,
-  fieldConfigs
-}) => {
-  const { uid: uidField, ...fields } = collectCustomTypeFields(model);
-  const hasDataFields = Object.keys(fields).length > 0;
-  const hasUIDField = Boolean(uidField);
-  let dataInterface;
-  if (hasDataFields) {
-    dataInterface = sourceFile.addInterface({
-      name: buildTypeName(model.id, "Document", "Data"),
-      docs: [
-        {
-          description: `Content for ${model.label} documents`
-        }
-      ]
-    });
-    for (const tabName in model.json) {
-      const { uid: _uidField, ...tabFields } = model.json[tabName];
-      addInterfacePropertiesForFields({
-        fields: tabFields,
-        interface: dataInterface,
-        sourceFile,
-        path: [
-          {
-            id: model.id,
-            model
-          }
-        ],
-        fieldConfigs,
-        tabName
-      });
-    }
-  } else {
-    dataInterface = sourceFile.addTypeAlias({
-      name: buildTypeName(model.id, "Document", "Data"),
-      type: `Record<string, never>`,
-      docs: [
-        {
-          description: `Content for ${model.label} documents`
-        }
-      ]
-    });
-  }
-  return sourceFile.addTypeAlias({
-    name: buildTypeName(model.id, "Document"),
-    typeParameters: [
-      {
-        name: "Lang",
-        constraint: "string",
-        default: localeIDs.length > 0 ? localeIDs.map((localeID) => `"${localeID}"`).join(" | ") : "string"
-      }
-    ],
-    type: hasUIDField ? `prismicT.PrismicDocumentWithUID<Simplify<${dataInterface.getName()}>, "${model.id}", Lang>` : `prismicT.PrismicDocumentWithoutUID<Simplify<${dataInterface.getName()}>, "${model.id}", Lang>`,
-    docs: [
-      {
-        description: (writer) => {
-          writer.writeLine(`${model.label} document from Prismic`);
-          writer.blankLine();
-          writer.writeLine(`- **API ID**: \`${model.id}\``);
-          writer.writeLine(`- **Repeatable**: \`${model.repeatable}\``);
-          writer.writeLine(
-            `- **Documentation**: ${CUSTOM_TYPES_DOCUMENTATION_URL}`
-          );
-        },
-        tags: [
-          {
-            tagName: "typeParam",
-            text: "Lang - Language API ID of the document."
-          }
-        ]
-      }
-    ],
-    isExported: true
-  });
-};
-
-const addTypeAliasForSharedSlice = (config) => {
-  const variationTypeNames = [];
-  for (const variation of config.model.variations) {
-    let primaryInterface;
-    if (variation.primary && Object.keys(variation.primary).length > 0) {
-      primaryInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-          variation.id,
-          "Primary"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  {
-                    id: config.model.id,
-                    model: config.model
-                  },
-                  {
-                    id: "primary",
-                    label: "Primary"
-                  }
-                ]
-              });
-              writer.writeLine(`Primary content in ${humanReadablePath}`);
-            }
-          }
-        ]
-      });
-      addInterfacePropertiesForFields({
-        interface: primaryInterface,
-        sourceFile: config.sourceFile,
-        fields: variation.primary,
-        path: [
-          {
-            id: config.model.id,
-            model: config.model
-          },
-          {
-            id: "primary",
-            label: "Primary"
-          }
-        ],
-        fieldConfigs: config.fieldConfigs
-      });
-    }
-    let itemInterface;
-    if (variation.items && Object.keys(variation.items).length > 0) {
-      itemInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-          variation.id,
-          "Item"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  {
-                    id: config.model.id,
-                    model: config.model
-                  },
-                  {
-                    id: "items",
-                    label: "Items"
-                  }
-                ]
-              });
-              writer.writeLine(`Item in ${humanReadablePath}`);
-            }
-          }
-        ],
-        isExported: true
-      });
-      addInterfacePropertiesForFields({
-        interface: itemInterface,
-        sourceFile: config.sourceFile,
-        fields: variation.items,
-        path: [
-          {
-            id: config.model.id,
-            model: config.model
-          },
-          {
-            id: "items",
-            label: "Items"
-          }
-        ],
-        fieldConfigs: config.fieldConfigs
-      });
-    }
-    const variationType = config.sourceFile.addTypeAlias({
-      name: buildTypeName(
-        buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-        variation.id
-      ),
-      type: `prismicT.SharedSliceVariation<"${variation.id}", ${primaryInterface ? `Simplify<${primaryInterface.getName()}>` : "Record<string, never>"}, ${itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"}>`,
-      docs: [
-        {
-          description: (writer) => {
-            writer.writeLine(
-              `${variation.name} variation for ${config.model.name} Slice`
-            );
-            writer.blankLine();
-            writer.writeLine(`- **API ID**: \`${variation.id}\``);
-            writer.writeLine(`- **Description**: \`${variation.description}\``);
-            writer.writeLine(
-              `- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`
-            );
-          }
-        }
-      ],
-      isExported: true
-    });
-    variationTypeNames.push(variationType.getName());
-  }
-  const variationsType = config.sourceFile.addTypeAlias({
-    name: buildTypeName(config.model.id, "Slice", "Variation"),
-    type: variationTypeNames.length > 0 ? variationTypeNames.join(" | ") : "never",
-    docs: [
-      {
-        description: (writer) => {
-          const humanReadablePath = getHumanReadableFieldPath({
-            path: [
-              {
-                id: config.model.id,
-                model: config.model
-              }
-            ]
-          });
-          writer.writeLine(`Slice variation for *${humanReadablePath}*`);
-        }
-      }
-    ]
-  });
-  return config.sourceFile.addTypeAlias({
-    name: buildTypeName(
-      buildSharedSliceInterfaceNamePart({ id: config.model.id })
-    ),
-    type: `prismicT.SharedSlice<"${config.model.id}", ${variationsType.getName()}>`,
-    docs: [
-      {
-        description: (writer) => {
-          writer.writeLine(`${config.model.name} Shared Slice`);
-          writer.blankLine();
-          writer.writeLine(`- **API ID**: \`${config.model.id}\``);
-          writer.writeLine(
-            `- **Description**: \`${config.model.description}\``
-          );
-          writer.writeLine(
-            `- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`
-          );
-        }
-      }
-    ],
-    isExported: true
-  });
-};
-
-const getSourceFileText = (sourceFile) => {
-  const text = sourceFile.print().replace(new RegExp(BLANK_LINE_IDENTIFIER, "g"), "");
-  return text;
-};
-
-const generateTypes = (config = {}) => {
-  const project = new Project({
-    useInMemoryFileSystem: true
-  });
-  const sourceFile = project.createSourceFile("types.d.ts");
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: "@prismicio/types",
-    namespaceImport: "prismicT",
-    isTypeOnly: true
-  });
-  sourceFile.addStatements(BLANK_LINE_IDENTIFIER);
-  const simplifyTypeAlias = sourceFile.addTypeAlias({
-    name: "Simplify",
-    typeParameters: [
-      {
-        name: "T"
-      }
-    ],
-    type: `{ [KeyType in keyof T]: T[KeyType] }`
-  });
-  if (config.customTypeModels) {
-    for (const model of config.customTypeModels) {
-      addTypeAliasForCustomType({
-        model,
-        sourceFile,
-        localeIDs: config.localeIDs || [],
-        fieldConfigs: config.fieldConfigs || {}
-      });
-    }
-    if (config.customTypeModels.length > 0) {
-      sourceFile.addTypeAlias({
-        name: "AllDocumentTypes",
-        type: config.customTypeModels.map(
-          (customTypeModel) => buildTypeName(customTypeModel.id, "Document")
-        ).join(" | "),
-        isExported: true
-      });
-    }
-  }
-  if (config.sharedSliceModels) {
-    for (const model of config.sharedSliceModels) {
-      addTypeAliasForSharedSlice({
-        model,
-        sourceFile,
-        fieldConfigs: config.fieldConfigs || {}
-      });
-    }
-  }
-  if (config.clientIntegration?.includeCreateClientInterface || config.clientIntegration?.includeContentNamespace) {
-    sourceFile.addImportDeclaration({
-      moduleSpecifier: "@prismicio/client",
-      namespaceImport: "prismic",
-      isTypeOnly: true
-    });
-    const clientModuleDeclaration = sourceFile.addModule({
-      name: '"@prismicio/client"',
-      hasDeclareKeyword: true,
-      declarationKind: ModuleDeclarationKind.Module
-    });
-    if (config.clientIntegration.includeCreateClientInterface) {
-      clientModuleDeclaration.addInterface({
-        name: "CreateClient",
-        callSignatures: [
-          {
-            parameters: [
-              {
-                name: "repositoryNameOrEndpoint",
-                type: "string"
-              },
-              {
-                name: "options",
-                type: "prismic.ClientConfig",
-                hasQuestionToken: true
-              }
-            ],
-            returnType: (config.customTypeModels?.length || 0) > 0 ? "prismic.Client<AllDocumentTypes>" : "prismic.Client"
-          }
-        ]
-      });
-    }
-    if (config.clientIntegration.includeContentNamespace) {
-      const contentNamespaceDeclaration = clientModuleDeclaration.addModule({
-        name: "Content",
-        declarationKind: ModuleDeclarationKind.Namespace
-      });
-      const exportSymbols = sourceFile.getExportSymbols().filter((exportSymbol) => {
-        return exportSymbol.getName() !== simplifyTypeAlias.getName();
-      });
-      contentNamespaceDeclaration.addExportDeclaration({
-        isTypeOnly: true,
-        namedExports: exportSymbols.map((exportSymbol) => {
-          return {
-            name: exportSymbol.getName()
-          };
-        })
-      });
-    }
-  }
-  return getSourceFileText(sourceFile);
-};
-
-const configSchema = Joi.object({
-  repositoryName: Joi.string().when("locales.fetchFromRepository", {
-    is: true,
-    then: Joi.required()
-  }).when("models.fetchFromRepository", {
-    is: true,
-    then: Joi.required()
-  }),
-  accessToken: Joi.string(),
-  customTypesAPIToken: Joi.string(),
-  output: Joi.string(),
-  clientIntegration: Joi.object({
-    includeCreateClientInterface: Joi.boolean(),
-    includeContentNamespace: Joi.boolean()
-  }),
-  locales: Joi.alternatives(
-    Joi.array().items(Joi.string().required()),
-    Joi.object({
-      ids: Joi.array().items(Joi.string().required()),
-      fetchFromRepository: Joi.boolean()
-    })
-  ),
-  models: Joi.alternatives(
-    Joi.array().items(Joi.string()),
-    Joi.object({
-      files: Joi.array().items(Joi.string()),
-      fetchFromRepository: Joi.boolean()
-    })
-  ),
-  fields: Joi.object({
-    embed: Joi.object({
-      providerTypes: Joi.object().pattern(
-        Joi.string(),
-        Joi.string().required()
-      )
-    }),
-    integrationFields: Joi.object({
-      catalogTypes: Joi.object().pattern(Joi.string(), Joi.string().required())
-    })
-  })
-});
-
-const loadLocaleIDs = async (config) => {
-  const localeIDs = new Set(config.localeIDs || []);
-  if ("repositoryName" in config && config.fetchFromRepository) {
-    const client = prismic.createClient(config.repositoryName, {
-      accessToken: config.accessToken,
-      fetch
-    });
-    const repository = await client.getRepository();
-    for (const language of repository.languages) {
-      localeIDs.add(language.id);
-    }
-  }
-  return [...localeIDs];
-};
-
-const isCustomTypeModel = (input) => {
-  return typeof input === "object" && input !== null && "json" in input;
-};
-const isSharedSliceModel = (input) => {
-  return typeof input === "object" && input !== null && "variations" in input;
-};
-const readJSONFromGlob = async (globs) => {
-  const paths = await fg(globs.split(",").map((path) => path.trim()));
-  return paths.map((path) => {
-    const raw = readFileSync(path, "utf8");
-    return JSON.parse(raw);
-  });
-};
-const loadModels = async (config) => {
-  const customTypeModels = {};
-  const sharedSliceModels = {};
-  if ("customTypesAPIToken" in config) {
-    const customTypesClient = prismicCT.createClient({
-      repositoryName: config.repositoryName,
-      token: config.customTypesAPIToken,
-      fetch
-    });
-    if (config.fetchFromRepository) {
-      const [remoteCustomTypeModels, remoteSharedSliceModels] = await Promise.all([
-        customTypesClient.getAllCustomTypes(),
-        customTypesClient.getAllSharedSlices()
-      ]);
-      for (const customTypeModel of remoteCustomTypeModels) {
-        customTypeModels[customTypeModel.id] = customTypeModel;
-      }
-      for (const sharedSliceModel of remoteSharedSliceModels) {
-        sharedSliceModels[sharedSliceModel.id] = sharedSliceModel;
-      }
-    }
-  }
-  if (config.localPaths) {
-    const models = (await Promise.all(config.localPaths.map((glob) => readJSONFromGlob(glob)))).flat();
-    for (const model of models) {
-      if (isCustomTypeModel(model)) {
-        customTypeModels[model.id] = model;
-      } else if (isSharedSliceModel(model)) {
-        sharedSliceModels[model.id] = model;
-      }
-    }
-  }
-  return {
-    customTypeModels: Object.values(customTypeModels).sort((a, b) => {
-      return a.id.localeCompare(b.id);
-    }),
-    sharedSliceModels: Object.values(sharedSliceModels).sort((a, b) => {
-      return a.id.localeCompare(b.id);
-    })
-  };
-};
-
-const jiti = _jiti(process.cwd());
-const loadModuleWithJiti = (id) => {
-  const mod = jiti(id);
-  return "default" in mod ? mod.default : mod;
-};
-const DEFAULT_CONFIG_PATHS = [
-  "prismicCodegen.config.ts",
-  "prismicCodegen.config.js"
-];
-const loadConfig = (config) => {
-  if (config.path) {
-    if (existsSync(config.path)) {
-      return loadModuleWithJiti(resolve(config.path));
-    } else {
-      throw new Error(`Config file does not exist: ${config.path}`);
-    }
-  } else {
-    for (const configPath of DEFAULT_CONFIG_PATHS) {
-      if (existsSync(configPath)) {
-        return loadModuleWithJiti(resolve(configPath));
-      }
-    }
-  }
-  return {};
-};
-
-const NON_EDITABLE_FILE_HEADER = "// Code generated by prismic-ts-codegen. DO NOT EDIT.";
-
-const cli = meow(
-  `
-	Usage:
-	    prismic-ts-codegen [options...]
-	    prismic-ts-codegen init [options...]
-
-	Commands:
-	    init [options]
-
-	Options:
-	    -c, --config <path>  Path to a prismic-ts-codegen configuration file.
-	`,
-  {
-    importMeta: import.meta,
-    flags: {
-      config: {
-        type: "string",
-        alias: "c",
-        isRequired: false
-      }
-    }
-  }
-);
-const main = async () => {
-  if (cli.input[0] === "init") {
-    const configPath = cli.flags.config || "prismicCodegen.config.ts";
-    if (existsSync(configPath)) {
-      console.info(`
-${configPath} already exists.`);
-    } else {
-      let contents = "";
-      if (existsSync("sm.json")) {
-        contents = stripIndent`
-					import type { Config } from "prismic-ts-codegen";
-
-					const config: Config = {
-					  output: "./types.generated.ts",
-					  models: ["./customtypes/**/index.json", "./slices/**/model.json"],
-					};
-
-					export default config;
-				`;
-      } else {
-        contents = stripIndent`
-					import type { Config } from "prismic-ts-codegen";
-
-					const config: Config = {
-					  output: "./types.generated.ts",
-					};
-
-					export default config;
-				`;
-      }
-      writeFileSync(configPath, contents);
-      console.info(`
-Created prismic-ts-codegen config file: ${configPath}`);
-    }
-  } else {
-    const unvalidatedConfig = loadConfig({ path: cli.flags.config });
-    const { value: config, error } = configSchema.validate(unvalidatedConfig);
-    if (config && !error) {
-      const { customTypeModels, sharedSliceModels } = await loadModels({
-        localPaths: Array.isArray(config.models) ? config.models : config.models?.files,
-        repositoryName: config.repositoryName,
-        customTypesAPIToken: config.customTypesAPIToken,
-        fetchFromRepository: config.models && "fetchFromRepository" in config.models && config.models.fetchFromRepository
-      });
-      const localeIDs = await loadLocaleIDs({
-        localeIDs: Array.isArray(config.locales) ? config.locales : config.locales?.ids,
-        repositoryName: config.repositoryName,
-        accessToken: config.accessToken,
-        fetchFromRepository: config.locales && "fetchFromRepository" in config.locales && config.locales.fetchFromRepository
-      });
-      const hasCustomTypeModels = customTypeModels.length > 0;
-      if (config.clientIntegration?.includeCreateClientInterface && !hasCustomTypeModels) {
-        console.info(
-          "[INFO]: prismic-ts-codegen was configured to automatically integrate with `@prismicio/client`, but the integration was not generated because no Custom Type models were found. Automatic integration requires at least one Custom Type model."
-        );
-      }
-      const types = generateTypes({
-        customTypeModels,
-        sharedSliceModels,
-        localeIDs,
-        fieldConfigs: config.fields,
-        clientIntegration: {
-          includeCreateClientInterface: hasCustomTypeModels ? config.clientIntegration?.includeCreateClientInterface ?? true : false,
-          includeContentNamespace: config.clientIntegration?.includeContentNamespace ?? true
-        }
-      });
-      const fileContents = `${NON_EDITABLE_FILE_HEADER}
-
-${types}`;
-      if (config.output) {
-        writeFileSync(resolve(config.output), fileContents);
-        console.info(`
-Generated types in: ${config.output}`);
-      } else {
-        process.stdout.write(types + "\n");
-      }
-    } else {
-      if (error) {
-        console.error(error.message);
-        return;
-      }
-    }
-  }
-};
-main().catch((error) => console.error(error));
-//# sourceMappingURL=cli.mjs.map