prismic-ts-codegen 0.0.2

package/bin/cli.mjs

@@ -0,0 +1,1166 @@
+#!/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 } from 'ts-morph';
+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 NON_EDITABLE_FILE_HEADER = stripIndent`
+	// Code generated by prismic-ts-codegen. DO NOT EDIT.
+	${BLANK_LINE_IDENTIFIER}
+`;
+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"
+};
+
+const CustomTypeModelFieldType = {
+  Boolean: "Boolean",
+  Color: "Color",
+  Date: "Date",
+  Embed: "Embed",
+  GeoPoint: "GeoPoint",
+  Group: "Group",
+  Image: "Image",
+  IntegrationFields: "IntegrationFields",
+  Link: "Link",
+  Number: "Number",
+  Select: "Select",
+  Slices: "Slices",
+  StructuredText: "StructuredText",
+  Text: "Text",
+  Timestamp: "Timestamp",
+  UID: "UID"
+};
+const CustomTypeModelLinkSelectType = {
+  Document: "document",
+  Media: "media"
+};
+const CustomTypeModelSliceType = {
+  Slice: "Slice",
+  SharedSlice: "SharedSlice"
+};
+
+const isCustomTypeModelField = (model) => {
+  return typeof model === "object" && model !== null && "type" in model && "config" in model;
+};
+
+const isCustomTypeModelSlice = (model) => {
+  return typeof model === "object" && model !== null && "non-repeat" in model && "repeat" in model;
+};
+
+const isSharedSliceModel$1 = (model) => {
+  return typeof model === "object" && model !== null && "variations" in model;
+};
+
+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;
+  } else if (isSharedSliceModel$1(config.model)) {
+    return config.model.name;
+  } else if (isCustomTypeModelField(config.model) && "label" in config.model.config) {
+    return config.model.config.label;
+  } else if (isCustomTypeModelSlice(config.model)) {
+    return config.model.fieldset;
+  } else {
+    return `Slice Zone (\`${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 = "single" in config.model.config && config.model.config.single.split(",").every((blockType) => /heading/.test(blockType));
+      return isTitleField ? "Title" : "Rich Text";
+    }
+    case "IntegrationFields": {
+      return `Integration Fields (Catalog: \`${config.model.config.catalog}\`)`;
+    }
+    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.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 = "placeholder" in config.model.config && config.model.config.placeholder ? config.model.config.placeholder : `*None*`;
+        const defaultValue = "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,
+          documentationURL: getFieldDocumentationURL({ model: config.model })
+        });
+      }
+    }
+  ];
+};
+
+const pascalCase = (input) => pascalCase$1(input, {
+  transform: pascalCaseTransformMerge
+});
+
+const buildSharedSliceInterfaceName = (config) => {
+  return pascalCase(`${config.id} Slice`);
+};
+
+const addInterfacePropertyFromField = (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
+        })
+      });
+      break;
+    }
+    case "Color": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.ColorField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "Date": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.DateField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      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
+        })
+      });
+      break;
+    }
+    case "GeoPoint": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.GeoPointField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "Image": {
+      if (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
+          })
+        });
+      } else {
+        config.interface.addProperty({
+          name: config.id,
+          type: "prismicT.ImageField<null>",
+          docs: buildFieldDocs({
+            id: config.id,
+            model: config.model,
+            path: config.path
+          })
+        });
+      }
+      break;
+    }
+    case "IntegrationFields": {
+      const catalogType = config.fieldConfigs.integrationFields?.catalogTypes?.[config.model.config.catalog];
+      config.interface.addProperty({
+        name: config.id,
+        type: catalogType ? `prismicT.IntegrationFields<${catalogType}>` : "prismicT.IntegrationFields",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "Link": {
+      switch (config.model.config.select) {
+        case CustomTypeModelLinkSelectType.Document: {
+          config.interface.addProperty({
+            name: config.id,
+            type: 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
+            })
+          });
+          break;
+        }
+        case CustomTypeModelLinkSelectType.Media: {
+          config.interface.addProperty({
+            name: config.id,
+            type: "prismicT.LinkToMediaField",
+            docs: buildFieldDocs({
+              id: config.id,
+              model: config.model,
+              path: config.path
+            })
+          });
+          break;
+        }
+        default: {
+          config.interface.addProperty({
+            name: config.id,
+            type: "prismicT.LinkField",
+            docs: buildFieldDocs({
+              id: config.id,
+              model: config.model,
+              path: config.path
+            })
+          });
+        }
+      }
+      break;
+    }
+    case "Number": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.NumberField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "StructuredText": {
+      const isTitleField = "single" in config.model.config && 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
+          })
+        });
+      } else {
+        config.interface.addProperty({
+          name: config.id,
+          type: "prismicT.RichTextField",
+          docs: buildFieldDocs({
+            id: config.id,
+            model: config.model,
+            path: config.path
+          })
+        });
+      }
+      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}, "filled">`,
+          docs: buildFieldDocs({
+            id: config.id,
+            model: config.model,
+            path: config.path
+          })
+        });
+      } else {
+        config.interface.addProperty({
+          name: config.id,
+          type: `prismicT.SelectField<${options}>`,
+          docs: buildFieldDocs({
+            id: config.id,
+            model: config.model,
+            path: config.path
+          })
+        });
+      }
+      break;
+    }
+    case "Text": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.KeyTextField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "Timestamp": {
+      config.interface.addProperty({
+        name: config.id,
+        type: "prismicT.TimestampField",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+      break;
+    }
+    case "Group": {
+      const itemInterface = config.sourceFile.addInterface({
+        name: pascalCase(`${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}`);
+            }
+          }
+        ]
+      });
+      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
+        })
+      });
+      break;
+    }
+    case "Slices": {
+      const choiceInterfaceNames = [];
+      for (const choiceId in config.model.config.choices) {
+        const choice = config.model.config.choices[choiceId];
+        if (choice.type === CustomTypeModelSliceType.SharedSlice) {
+          choiceInterfaceNames.push(buildSharedSliceInterfaceName({ id: choiceId }));
+        } else if (choice.type === CustomTypeModelSliceType.Slice) {
+          let primaryInterface;
+          if (Object.keys(choice["non-repeat"]).length > 0) {
+            primaryInterface = config.sourceFile.addInterface({
+              name: pascalCase(`${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 (Object.keys(choice.repeat).length > 0) {
+            itemInterface = config.sourceFile.addInterface({
+              name: pascalCase(`${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}`);
+                  }
+                }
+              ]
+            });
+            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: pascalCase(`${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"}>`
+          });
+          choiceInterfaceNames.push(sliceType.getName());
+        }
+      }
+      const slicesType = config.sourceFile.addTypeAlias({
+        name: pascalCase(`${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
+        })
+      });
+      break;
+    }
+    default: {
+      config.interface.addProperty({
+        name: config.id,
+        type: "unknown",
+        docs: buildFieldDocs({
+          id: config.id,
+          model: config.model,
+          path: config.path
+        })
+      });
+    }
+  }
+};
+const addInterfacePropertiesForFields = (config) => {
+  for (const name in config.fields) {
+    addInterfacePropertyFromField({
+      ...config,
+      id: name,
+      model: config.fields[name]
+    });
+  }
+};
+
+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: pascalCase(`${model.id} Document Data`),
+      docs: [
+        {
+          description: `Content for ${model.label} documents`
+        }
+      ]
+    });
+    addInterfacePropertiesForFields({
+      fields,
+      interface: dataInterface,
+      sourceFile,
+      path: [
+        {
+          id: model.id,
+          model
+        }
+      ],
+      fieldConfigs
+    });
+  } else {
+    dataInterface = sourceFile.addTypeAlias({
+      name: pascalCase(`${model.id} Document Data`),
+      type: `Record<string, never>`,
+      docs: [
+        {
+          description: `Content for ${model.label} documents`
+        }
+      ]
+    });
+  }
+  return sourceFile.addTypeAlias({
+    name: pascalCase(`${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 (Object.keys(variation.primary).length > 0) {
+      primaryInterface = config.sourceFile.addInterface({
+        name: pascalCase(`${buildSharedSliceInterfaceName({ 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 (Object.keys(variation.items).length > 0) {
+      itemInterface = config.sourceFile.addInterface({
+        name: pascalCase(`${buildSharedSliceInterfaceName({ 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}`);
+            }
+          }
+        ]
+      });
+      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: pascalCase(`${buildSharedSliceInterfaceName({
+        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}`);
+          }
+        }
+      ]
+    });
+    variationTypeNames.push(variationType.getName());
+  }
+  const variationsType = config.sourceFile.addTypeAlias({
+    name: pascalCase(`${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: pascalCase(buildSharedSliceInterfaceName({
+      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,
+    leadingTrivia: NON_EDITABLE_FILE_HEADER
+  });
+  sourceFile.addStatements(BLANK_LINE_IDENTIFIER);
+  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.sharedSliceModels) {
+    for (const model of config.sharedSliceModels) {
+      addTypeAliasForSharedSlice({
+        model,
+        sourceFile,
+        fieldConfigs: config.fieldConfigs || {}
+      });
+    }
+  }
+  return getSourceFileText(sourceFile);
+};
+
+const configSchema = Joi.object({
+  repositoryName: Joi.string(),
+  accessToken: Joi.string(),
+  customTypesAPIToken: Joi.string(),
+  output: Joi.string(),
+  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().required()), Joi.object({
+    files: Joi.array().items(Joi.string().required()),
+    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())
+    })
+  })
+}).when(Joi.object({
+  locales: Joi.object({
+    fetchFromRepository: Joi.valid(true)
+  })
+}), {
+  then: Joi.object({
+    repositoryName: Joi.required()
+  })
+}).when(Joi.object({
+  models: Joi.object({
+    fetchFromRepository: Joi.valid(true)
+  })
+}), {
+  then: Joi.object({
+    repositoryName: Joi.required(),
+    customTypesAPIToken: Joi.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.getAll(),
+        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),
+    sharedSliceModels: Object.values(sharedSliceModels)
+  };
+};
+
+const jiti = _jiti(process.cwd());
+const DEFAULT_CONFIG_PATHS = [
+  "prismicCodegen.config.ts",
+  "prismicCodegen.config.js"
+];
+const loadConfig = (config) => {
+  if (config.path) {
+    if (existsSync(config.path)) {
+      return jiti(config.path);
+    } else {
+      throw new Error(`Config file does not exist: ${config.path}`);
+    }
+  } else {
+    for (const configPath of DEFAULT_CONFIG_PATHS) {
+      if (existsSync(configPath)) {
+        const mod = jiti(resolve(configPath));
+        return "default" in mod ? mod.default : mod;
+      }
+    }
+  }
+  return {};
+};
+
+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 types = generateTypes({
+        customTypeModels,
+        sharedSliceModels,
+        localeIDs
+      });
+      if (config.output) {
+        writeFileSync(resolve(config.output), types);
+      } else {
+        process.stdout.write(types + "\n");
+      }
+    } else {
+      if (error) {
+        console.error(error.message);
+        return;
+      }
+    }
+  }
+};
+main().catch((error) => console.error(error));
+//# sourceMappingURL=cli.mjs.map