@sanity/cli 7.10.0 → 7.12.0

package/dist/actions/migration/ensureApiVersionFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/ensureApiVersionFormat.ts"],"sourcesContent":["import {type APIConfig} from '@sanity/migrate'\n\ntype ApiVersion = APIConfig['apiVersion']\n\nconst VERSION_PATTERN = /^v\\d+-\\d+-\\d+$|^vX$/ // Matches version strings like vYYYY-MM-DD or vX\n\n/**\n * Ensures that the provided API version string is in the correct format.\n * If the version does not start with 'v', it will be prefixed with 'v'.\n * If the version does not match the expected pattern, an error will be thrown.\n */\nexport function ensureApiVersionFormat(version: string): ApiVersion {\n  const normalizedVersion = version.startsWith('v') ? version : `v${version}`\n\n  // Check if the version matches the expected pattern\n  if (!VERSION_PATTERN.test(normalizedVersion)) {\n    throw new Error(\n      `Invalid API version format: ${normalizedVersion}. Expected format: vYYYY-MM-DD or vX`,\n    )\n  }\n\n  return normalizedVersion as ApiVersion\n}\n"],"names":["VERSION_PATTERN","ensureApiVersionFormat","version","normalizedVersion","startsWith","test","Error"],"mappings":"AAIA,MAAMA,kBAAkB,sBAAsB,iDAAiD;;AAE/F;;;;CAIC,GACD,OAAO,SAASC,uBAAuBC,OAAe;IACpD,MAAMC,oBAAoBD,QAAQE,UAAU,CAAC,OAAOF,UAAU,CAAC,CAAC,EAAEA,SAAS;IAE3E,oDAAoD;IACpD,IAAI,CAACF,gBAAgBK,IAAI,CAACF,oBAAoB;QAC5C,MAAM,IAAIG,MACR,CAAC,4BAA4B,EAAEH,kBAAkB,oCAAoC,CAAC;IAE1F;IAEA,OAAOA;AACT"}

package/dist/actions/migration/fileExists.js

@@ -0,0 +1,13 @@
+import { access } from 'node:fs/promises';
+/**
+ * Checks if a file exists and can be "accessed".
+ * Prone to race conditions, but good enough for our use cases.
+ *
+ * @param filePath - The path to the file to check
+ * @returns A promise that resolves to true if the file exists, false otherwise
+ * @internal
+ */ export function fileExists(filePath) {
+    return access(filePath).then(()=>true, ()=>false);
+}
+
+//# sourceMappingURL=fileExists.js.map

package/dist/actions/migration/fileExists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/fileExists.ts"],"sourcesContent":["import {access} from 'node:fs/promises'\n\n/**\n * Checks if a file exists and can be \"accessed\".\n * Prone to race conditions, but good enough for our use cases.\n *\n * @param filePath - The path to the file to check\n * @returns A promise that resolves to true if the file exists, false otherwise\n * @internal\n */\nexport function fileExists(filePath: string): Promise<boolean> {\n  return access(filePath).then(\n    () => true,\n    () => false,\n  )\n}\n"],"names":["access","fileExists","filePath","then"],"mappings":"AAAA,SAAQA,MAAM,QAAO,mBAAkB;AAEvC;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,QAAgB;IACzC,OAAOF,OAAOE,UAAUC,IAAI,CAC1B,IAAM,MACN,IAAM;AAEV"}

package/dist/actions/migration/prettyMutationFormatter.js

@@ -0,0 +1,155 @@
+import { isatty } from 'node:tty';
+import { styleText } from 'node:util';
+import { convertToTree, formatTree, maxKeyLength } from './tree.js';
+const isTty = isatty(1);
+export function prettyFormat({ indentSize = 0, migration, subject }) {
+    return (Array.isArray(subject) ? subject : [
+        subject
+    ]).map((subjectEntry)=>{
+        if (subjectEntry.type === 'transaction') {
+            return [
+                [
+                    badge('transaction', 'info'),
+                    subjectEntry.id === undefined ? null : styleText('underline', subjectEntry.id)
+                ].filter(Boolean).join(' '),
+                indent(prettyFormat({
+                    indentSize: indentSize,
+                    migration,
+                    subject: subjectEntry.mutations
+                }))
+            ].join('\n\n');
+        }
+        return prettyFormatMutation({
+            indentSize,
+            migration,
+            subject: subjectEntry
+        });
+    }).join('\n\n');
+}
+function encodeItemRef(ref) {
+    return typeof ref === 'number' ? ref : ref._key;
+}
+function badgeStyle(variant, label) {
+    const styles = {
+        destructive: styleText([
+            'bgRed',
+            'black',
+            'bold'
+        ], label),
+        incremental: styleText([
+            'bgGreen',
+            'black',
+            'bold'
+        ], label),
+        info: styleText([
+            'bgWhite',
+            'black'
+        ], label),
+        maybeDestructive: styleText([
+            'bgYellow',
+            'black',
+            'bold'
+        ], label)
+    };
+    return styles[variant];
+}
+function badge(label, variant) {
+    if (!isTty) {
+        return `[${label}]`;
+    }
+    return badgeStyle(variant, ` ${label} `);
+}
+const mutationImpact = {
+    create: 'incremental',
+    createIfNotExists: 'incremental',
+    createOrReplace: 'maybeDestructive',
+    delete: 'destructive',
+    patch: 'maybeDestructive'
+};
+function documentId(mutation) {
+    if ('id' in mutation) {
+        return mutation.id;
+    }
+    if ('document' in mutation) {
+        return mutation.document._id;
+    }
+    return undefined;
+}
+const listFormatter = new Intl.ListFormat('en-US', {
+    type: 'disjunction'
+});
+function mutationHeader(mutation, migration) {
+    const mutationType = badge(mutation.type, mutationImpact[mutation.type]);
+    const documentType = 'document' in mutation || migration.documentTypes ? badge('document' in mutation ? mutation.document._type : listFormatter.format(migration.documentTypes ?? []), 'info') : null;
+    // TODO: Should we list documentType when a mutation can be yielded for any document type?
+    return [
+        mutationType,
+        documentType,
+        styleText('underline', documentId(mutation) ?? '')
+    ].filter(Boolean).join(' ');
+}
+function prettyFormatMutation({ indentSize = 0, migration, subject }) {
+    const lock = 'options' in subject ? styleText('cyan', `(if revision==${subject.options?.ifRevision})`) : '';
+    const header = [
+        mutationHeader(subject, migration),
+        lock
+    ].join(' ');
+    const padding = ' '.repeat(indentSize);
+    if (subject.type === 'create' || subject.type === 'createIfNotExists' || subject.type === 'createOrReplace') {
+        return [
+            header,
+            '\n',
+            indent(JSON.stringify(subject.document, null, 2), indentSize)
+        ].join('');
+    }
+    if (subject.type === 'patch') {
+        const tree = convertToTree(subject.patches.flat());
+        const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30);
+        return [
+            header,
+            '\n',
+            formatTree({
+                getMessage: (patch)=>formatPatchMutation(patch),
+                indent: padding,
+                node: tree.children,
+                paddingLength
+            })
+        ].join('');
+    }
+    return header;
+}
+function formatPatchMutation(patch) {
+    const { op } = patch;
+    const formattedType = styleText('bold', op.type);
+    if (op.type === 'unset') {
+        return `${styleText('red', formattedType)}()`;
+    }
+    if (op.type === 'diffMatchPatch') {
+        return `${styleText('yellow', formattedType)}(${op.value})`;
+    }
+    if (op.type === 'inc' || op.type === 'dec') {
+        return `${styleText('yellow', formattedType)}(${op.amount})`;
+    }
+    if (op.type === 'set') {
+        return `${styleText('yellow', formattedType)}(${JSON.stringify(op.value)})`;
+    }
+    if (op.type === 'setIfMissing') {
+        return `${styleText('green', formattedType)}(${JSON.stringify(op.value)})`;
+    }
+    if (op.type === 'insert') {
+        return `${styleText('green', formattedType)}(${op.position}, ${encodeItemRef(op.referenceItem)}, ${JSON.stringify(op.items)})`;
+    }
+    if (op.type === 'replace') {
+        return `${styleText('yellow', formattedType)}(${encodeItemRef(op.referenceItem)}, ${JSON.stringify(op.items)})`;
+    }
+    if (op.type === 'truncate') {
+        return `${styleText('red', formattedType)}(${op.startIndex}, ${op.endIndex})`;
+    }
+    throw new Error(`Invalid operation type: ${op.type}`);
+}
+function indent(subject, size = 2) {
+    const padding = ' '.repeat(size);
+    return subject.split('\n').map((line)=>padding + line).join('\n');
+}
+
+//# sourceMappingURL=prettyMutationFormatter.js.map

package/dist/actions/migration/prettyMutationFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/prettyMutationFormatter.ts"],"sourcesContent":["import {isatty} from 'node:tty'\nimport {styleText} from 'node:util'\n\nimport {type Migration, type Mutation, type NodePatch, type Transaction} from '@sanity/migrate'\nimport {type KeyedSegment} from '@sanity/types'\n\nimport {convertToTree, formatTree, maxKeyLength} from './tree.js'\n\ntype ItemRef = number | string\ntype Impact = 'destructive' | 'incremental' | 'maybeDestructive'\ntype Variant = 'info' | Impact\n\nconst isTty = isatty(1)\n\ninterface FormatterOptions<Subject> {\n  migration: Migration\n  subject: Subject\n\n  indentSize?: number\n}\n\nexport function prettyFormat({\n  indentSize = 0,\n  migration,\n  subject,\n}: FormatterOptions<(Mutation | Transaction)[] | Mutation | Transaction>): string {\n  return (Array.isArray(subject) ? subject : [subject])\n    .map((subjectEntry) => {\n      if (subjectEntry.type === 'transaction') {\n        return [\n          [\n            badge('transaction', 'info'),\n            subjectEntry.id === undefined ? null : styleText('underline', subjectEntry.id),\n          ]\n            .filter(Boolean)\n            .join(' '),\n          indent(\n            prettyFormat({\n              indentSize: indentSize,\n              migration,\n              subject: subjectEntry.mutations,\n            }),\n          ),\n        ].join('\\n\\n')\n      }\n      return prettyFormatMutation({\n        indentSize,\n        migration,\n        subject: subjectEntry,\n      })\n    })\n    .join('\\n\\n')\n}\n\nfunction encodeItemRef(ref: KeyedSegment | number): ItemRef {\n  return typeof ref === 'number' ? ref : ref._key\n}\n\nfunction badgeStyle(variant: Variant, label: string) {\n  const styles: Record<Variant, string> = {\n    destructive: styleText(['bgRed', 'black', 'bold'], label),\n    incremental: styleText(['bgGreen', 'black', 'bold'], label),\n    info: styleText(['bgWhite', 'black'], label),\n    maybeDestructive: styleText(['bgYellow', 'black', 'bold'], label),\n  }\n\n  return styles[variant]\n}\n\nfunction badge(label: string, variant: Variant): string {\n  if (!isTty) {\n    return `[${label}]`\n  }\n\n  return badgeStyle(variant, ` ${label} `)\n}\n\nconst mutationImpact: Record<Mutation['type'], Impact> = {\n  create: 'incremental',\n  createIfNotExists: 'incremental',\n  createOrReplace: 'maybeDestructive',\n  delete: 'destructive',\n  patch: 'maybeDestructive',\n}\n\nfunction documentId(mutation: Mutation): string | undefined {\n  if ('id' in mutation) {\n    return mutation.id\n  }\n\n  if ('document' in mutation) {\n    return mutation.document._id\n  }\n\n  return undefined\n}\n\nconst listFormatter = new Intl.ListFormat('en-US', {\n  type: 'disjunction',\n})\n\nfunction mutationHeader(mutation: Mutation, migration: Migration): string {\n  const mutationType = badge(mutation.type, mutationImpact[mutation.type])\n\n  const documentType =\n    'document' in mutation || migration.documentTypes\n      ? badge(\n          'document' in mutation\n            ? mutation.document._type\n            : listFormatter.format(migration.documentTypes ?? []),\n          'info',\n        )\n      : null\n\n  // TODO: Should we list documentType when a mutation can be yielded for any document type?\n  return [mutationType, documentType, styleText('underline', documentId(mutation) ?? '')]\n    .filter(Boolean)\n    .join(' ')\n}\n\nfunction prettyFormatMutation({\n  indentSize = 0,\n  migration,\n  subject,\n}: FormatterOptions<Mutation>): string {\n  const lock =\n    'options' in subject ? styleText('cyan', `(if revision==${subject.options?.ifRevision})`) : ''\n  const header = [mutationHeader(subject, migration), lock].join(' ')\n  const padding = ' '.repeat(indentSize)\n\n  if (\n    subject.type === 'create' ||\n    subject.type === 'createIfNotExists' ||\n    subject.type === 'createOrReplace'\n  ) {\n    return [header, '\\n', indent(JSON.stringify(subject.document, null, 2), indentSize)].join('')\n  }\n\n  if (subject.type === 'patch') {\n    const tree = convertToTree<NodePatch>(subject.patches.flat())\n    const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30)\n\n    return [\n      header,\n      '\\n',\n      formatTree<NodePatch>({\n        getMessage: (patch: NodePatch) => formatPatchMutation(patch),\n        indent: padding,\n        node: tree.children,\n        paddingLength,\n      }),\n    ].join('')\n  }\n\n  return header\n}\n\nfunction formatPatchMutation(patch: NodePatch): string {\n  const {op} = patch\n  const formattedType = styleText('bold', op.type)\n  if (op.type === 'unset') {\n    return `${styleText('red', formattedType)}()`\n  }\n  if (op.type === 'diffMatchPatch') {\n    return `${styleText('yellow', formattedType)}(${op.value})`\n  }\n  if (op.type === 'inc' || op.type === 'dec') {\n    return `${styleText('yellow', formattedType)}(${op.amount})`\n  }\n  if (op.type === 'set') {\n    return `${styleText('yellow', formattedType)}(${JSON.stringify(op.value)})`\n  }\n  if (op.type === 'setIfMissing') {\n    return `${styleText('green', formattedType)}(${JSON.stringify(op.value)})`\n  }\n  if (op.type === 'insert') {\n    return `${styleText('green', formattedType)}(${op.position}, ${encodeItemRef(\n      op.referenceItem,\n    )}, ${JSON.stringify(op.items)})`\n  }\n  if (op.type === 'replace') {\n    return `${styleText('yellow', formattedType)}(${encodeItemRef(op.referenceItem)}, ${JSON.stringify(\n      op.items,\n    )})`\n  }\n  if (op.type === 'truncate') {\n    return `${styleText('red', formattedType)}(${op.startIndex}, ${op.endIndex})`\n  }\n\n  throw new Error(`Invalid operation type: ${(op as {type: string}).type}`)\n}\n\nfunction indent(subject: string, size = 2): string {\n  const padding = ' '.repeat(size)\n\n  return subject\n    .split('\\n')\n    .map((line) => padding + line)\n    .join('\\n')\n}\n"],"names":["isatty","styleText","convertToTree","formatTree","maxKeyLength","isTty","prettyFormat","indentSize","migration","subject","Array","isArray","map","subjectEntry","type","badge","id","undefined","filter","Boolean","join","indent","mutations","prettyFormatMutation","encodeItemRef","ref","_key","badgeStyle","variant","label","styles","destructive","incremental","info","maybeDestructive","mutationImpact","create","createIfNotExists","createOrReplace","delete","patch","documentId","mutation","document","_id","listFormatter","Intl","ListFormat","mutationHeader","mutationType","documentType","documentTypes","_type","format","lock","options","ifRevision","header","padding","repeat","JSON","stringify","tree","patches","flat","paddingLength","Math","max","children","getMessage","formatPatchMutation","node","op","formattedType","value","amount","position","referenceItem","items","startIndex","endIndex","Error","size","split","line"],"mappings":"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"}

package/dist/actions/migration/resolveMigrationScript.js

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { importModule, subdebug } from '@sanity/cli-core';
+import { MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY } from './constants.js';
+import { fileExists } from './fileExists.js';
+const debug = subdebug('migration:resolveMigrationScript');
+/**
+ * Resolves the potential paths to a migration script.
+ * Considers the following paths (where `<ext>` is 'mjs', 'js', 'ts' or 'cjs'):
+ *
+ * - `<migrationsDir>/<migrationName>.<ext>`
+ * - `<migrationsDir>/<migrationName>/index.<ext>`
+ *
+ * Note that all possible paths are returned, even if the files do not exist.
+ * Check the `mod` property to see if a module could actually be loaded.
+ *
+ * @param workDir - Working directory of the studio
+ * @param migrationName - The name of the migration directory to resolve
+ * @returns An array of potential migration scripts
+ * @internal
+ */ export async function resolveMigrationScript(workDir, migrationName) {
+    const locations = [
+        migrationName,
+        path.join(migrationName, 'index')
+    ];
+    const results = [];
+    for (const location of locations){
+        for (const ext of MIGRATION_SCRIPT_EXTENSIONS){
+            const relativePath = path.join(MIGRATIONS_DIRECTORY, `${location}.${ext}`);
+            const absolutePath = path.resolve(workDir, relativePath);
+            let mod;
+            // Check if the file exists before trying to import it
+            const exists = await fileExists(absolutePath);
+            if (!exists) {
+                continue;
+            }
+            try {
+                debug(`importing migration from ${absolutePath}`);
+                const imported = await importModule(absolutePath, {
+                    default: false
+                });
+                // Handle both ESM and CJS default exports
+                mod = imported;
+            } catch (err) {
+                debug(`error importing migration from ${absolutePath}`, err);
+                // Ignore MODULE_NOT_FOUND errors, but throw others
+                if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+                    throw new Error(`Error loading migration: ${err.message}`, {
+                        cause: err
+                    });
+                }
+            }
+            results.push({
+                absolutePath,
+                mod,
+                relativePath
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Checks whether or not the passed resolved migration script is actually loadable (eg has a default export)
+ *
+ * @param script - The resolved migration script to check
+ * @returns `true` if the script is loadable, `false` otherwise
+ * @internal
+ */ export function isLoadableMigrationScript(script) {
+    if (script.mod === undefined || typeof script.mod.default !== 'object' || script.mod.default === null || Array.isArray(script.mod.default)) {
+        return false;
+    }
+    const mod = script.mod.default;
+    return typeof mod.title === 'string' && mod.migrate !== undefined;
+}
+
+//# sourceMappingURL=resolveMigrationScript.js.map

package/dist/actions/migration/resolveMigrationScript.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/resolveMigrationScript.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {importModule, subdebug} from '@sanity/cli-core'\nimport {type Migration} from '@sanity/migrate'\n\nimport {MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY} from './constants.js'\nimport {fileExists} from './fileExists.js'\n\ninterface ResolvedMigrationScript {\n  /**\n   * Absolute path to the migration script\n   */\n  absolutePath: string\n  /**\n   * Relative path from the working directory to the migration script\n   */\n  relativePath: string\n\n  /**\n   * The migration module, if it could be resolved - otherwise `undefined`\n   */\n  mod?: {default: Migration; down?: unknown; up?: unknown}\n}\n\nconst debug = subdebug('migration:resolveMigrationScript')\n\n/**\n * Resolves the potential paths to a migration script.\n * Considers the following paths (where `<ext>` is 'mjs', 'js', 'ts' or 'cjs'):\n *\n * - `<migrationsDir>/<migrationName>.<ext>`\n * - `<migrationsDir>/<migrationName>/index.<ext>`\n *\n * Note that all possible paths are returned, even if the files do not exist.\n * Check the `mod` property to see if a module could actually be loaded.\n *\n * @param workDir - Working directory of the studio\n * @param migrationName - The name of the migration directory to resolve\n * @returns An array of potential migration scripts\n * @internal\n */\nexport async function resolveMigrationScript(\n  workDir: string,\n  migrationName: string,\n): Promise<ResolvedMigrationScript[]> {\n  const locations = [migrationName, path.join(migrationName, 'index')]\n  const results: ResolvedMigrationScript[] = []\n\n  for (const location of locations) {\n    for (const ext of MIGRATION_SCRIPT_EXTENSIONS) {\n      const relativePath = path.join(MIGRATIONS_DIRECTORY, `${location}.${ext}`)\n      const absolutePath = path.resolve(workDir, relativePath)\n      let mod: {default: Migration; down?: unknown; up?: unknown} | undefined\n\n      // Check if the file exists before trying to import it\n      const exists = await fileExists(absolutePath)\n      if (!exists) {\n        continue\n      }\n\n      try {\n        debug(`importing migration from ${absolutePath}`)\n        const imported = await importModule<{default: Migration; down?: unknown; up?: unknown}>(\n          absolutePath,\n          {\n            default: false,\n          },\n        )\n        // Handle both ESM and CJS default exports\n        mod = imported\n      } catch (err) {\n        debug(`error importing migration from ${absolutePath}`, err)\n        // Ignore MODULE_NOT_FOUND errors, but throw others\n        if (\n          (err as NodeJS.ErrnoException).code !== 'MODULE_NOT_FOUND' &&\n          (err as NodeJS.ErrnoException).code !== 'ERR_MODULE_NOT_FOUND'\n        ) {\n          throw new Error(`Error loading migration: ${(err as Error).message}`, {cause: err})\n        }\n      }\n\n      results.push({absolutePath, mod, relativePath})\n    }\n  }\n\n  return results\n}\n\n/**\n * Checks whether or not the passed resolved migration script is actually loadable (eg has a default export)\n *\n * @param script - The resolved migration script to check\n * @returns `true` if the script is loadable, `false` otherwise\n * @internal\n */\nexport function isLoadableMigrationScript(\n  script: ResolvedMigrationScript,\n): script is Required<ResolvedMigrationScript> {\n  if (\n    script.mod === undefined ||\n    typeof script.mod.default !== 'object' ||\n    script.mod.default === null ||\n    Array.isArray(script.mod.default)\n  ) {\n    return false\n  }\n\n  const mod = script.mod.default\n  return typeof mod.title === 'string' && mod.migrate !== undefined\n}\n"],"names":["path","importModule","subdebug","MIGRATION_SCRIPT_EXTENSIONS","MIGRATIONS_DIRECTORY","fileExists","debug","resolveMigrationScript","workDir","migrationName","locations","join","results","location","ext","relativePath","absolutePath","resolve","mod","exists","imported","default","err","code","Error","message","cause","push","isLoadableMigrationScript","script","undefined","Array","isArray","title","migrate"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAE5B,SAAQC,YAAY,EAAEC,QAAQ,QAAO,mBAAkB;AAGvD,SAAQC,2BAA2B,EAAEC,oBAAoB,QAAO,iBAAgB;AAChF,SAAQC,UAAU,QAAO,kBAAiB;AAkB1C,MAAMC,QAAQJ,SAAS;AAEvB;;;;;;;;;;;;;;CAcC,GACD,OAAO,eAAeK,uBACpBC,OAAe,EACfC,aAAqB;IAErB,MAAMC,YAAY;QAACD;QAAeT,KAAKW,IAAI,CAACF,eAAe;KAAS;IACpE,MAAMG,UAAqC,EAAE;IAE7C,KAAK,MAAMC,YAAYH,UAAW;QAChC,KAAK,MAAMI,OAAOX,4BAA6B;YAC7C,MAAMY,eAAef,KAAKW,IAAI,CAACP,sBAAsB,GAAGS,SAAS,CAAC,EAAEC,KAAK;YACzE,MAAME,eAAehB,KAAKiB,OAAO,CAACT,SAASO;YAC3C,IAAIG;YAEJ,sDAAsD;YACtD,MAAMC,SAAS,MAAMd,WAAWW;YAChC,IAAI,CAACG,QAAQ;gBACX;YACF;YAEA,IAAI;gBACFb,MAAM,CAAC,yBAAyB,EAAEU,cAAc;gBAChD,MAAMI,WAAW,MAAMnB,aACrBe,cACA;oBACEK,SAAS;gBACX;gBAEF,0CAA0C;gBAC1CH,MAAME;YACR,EAAE,OAAOE,KAAK;gBACZhB,MAAM,CAAC,+BAA+B,EAAEU,cAAc,EAAEM;gBACxD,mDAAmD;gBACnD,IACE,AAACA,IAA8BC,IAAI,KAAK,sBACxC,AAACD,IAA8BC,IAAI,KAAK,wBACxC;oBACA,MAAM,IAAIC,MAAM,CAAC,yBAAyB,EAAE,AAACF,IAAcG,OAAO,EAAE,EAAE;wBAACC,OAAOJ;oBAAG;gBACnF;YACF;YAEAV,QAAQe,IAAI,CAAC;gBAACX;gBAAcE;gBAAKH;YAAY;QAC/C;IACF;IAEA,OAAOH;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASgB,0BACdC,MAA+B;IAE/B,IACEA,OAAOX,GAAG,KAAKY,aACf,OAAOD,OAAOX,GAAG,CAACG,OAAO,KAAK,YAC9BQ,OAAOX,GAAG,CAACG,OAAO,KAAK,QACvBU,MAAMC,OAAO,CAACH,OAAOX,GAAG,CAACG,OAAO,GAChC;QACA,OAAO;IACT;IAEA,MAAMH,MAAMW,OAAOX,GAAG,CAACG,OAAO;IAC9B,OAAO,OAAOH,IAAIe,KAAK,KAAK,YAAYf,IAAIgB,OAAO,KAAKJ;AAC1D"}

package/dist/actions/migration/resolveMigrations.js

@@ -0,0 +1,50 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY } from './constants.js';
+import { isLoadableMigrationScript, resolveMigrationScript } from './resolveMigrationScript.js';
+/**
+ * Removes migration script extensions from a filename
+ *
+ * @param fileName - The filename to process
+ * @returns The filename without the extension
+ * @internal
+ */ function removeMigrationScriptExtension(fileName) {
+    // Remove `.ts`, `.js` etc from the end of a filename
+    const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e)=>fileName.endsWith(`.${e}`));
+    return ext ? path.basename(fileName, `.${ext}`) : fileName;
+}
+/**
+ * Resolves all migrations in the studio working directory
+ *
+ * @param workDir - The studio working directory
+ * @returns Array of migrations and their respective paths
+ * @internal
+ */ export async function resolveMigrations(workDir) {
+    const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY);
+    const migrationEntries = await readdir(migrationsDir, {
+        withFileTypes: true
+    });
+    const migrations = [];
+    const seen = new Set();
+    for (const entry of migrationEntries){
+        const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name);
+        // A file (e.g. `foo.ts`) and a directory (e.g. `foo/`) can both map to the
+        // same id; only resolve each id once.
+        if (seen.has(entryName)) {
+            continue;
+        }
+        // `resolveMigrationScript` may return several loadable candidates for a
+        // single id (e.g. both `foo.ts` and `foo/index.ts`). List it just once.
+        const candidate = (await resolveMigrationScript(workDir, entryName)).find((script)=>isLoadableMigrationScript(script));
+        if (candidate) {
+            seen.add(entryName);
+            migrations.push({
+                id: entryName,
+                migration: candidate.mod.default
+            });
+        }
+    }
+    return migrations;
+}
+
+//# sourceMappingURL=resolveMigrations.js.map

package/dist/actions/migration/resolveMigrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/resolveMigrations.ts"],"sourcesContent":["import {readdir} from 'node:fs/promises'\nimport path from 'node:path'\n\nimport {type Migration} from '@sanity/migrate'\n\nimport {MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY} from './constants.js'\nimport {isLoadableMigrationScript, resolveMigrationScript} from './resolveMigrationScript.js'\n\n/**\n * A resolved migration, where you are guaranteed that the migration file exists\n *\n * @internal\n */\ninterface ResolvedMigration {\n  id: string\n  migration: Migration\n}\n\n/**\n * Removes migration script extensions from a filename\n *\n * @param fileName - The filename to process\n * @returns The filename without the extension\n * @internal\n */\nfunction removeMigrationScriptExtension(fileName: string): string {\n  // Remove `.ts`, `.js` etc from the end of a filename\n  const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e) => fileName.endsWith(`.${e}`))\n  return ext ? path.basename(fileName, `.${ext}`) : fileName\n}\n\n/**\n * Resolves all migrations in the studio working directory\n *\n * @param workDir - The studio working directory\n * @returns Array of migrations and their respective paths\n * @internal\n */\nexport async function resolveMigrations(workDir: string): Promise<ResolvedMigration[]> {\n  const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY)\n  const migrationEntries = await readdir(migrationsDir, {withFileTypes: true})\n\n  const migrations: ResolvedMigration[] = []\n  const seen = new Set<string>()\n  for (const entry of migrationEntries) {\n    const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name)\n    // A file (e.g. `foo.ts`) and a directory (e.g. `foo/`) can both map to the\n    // same id; only resolve each id once.\n    if (seen.has(entryName)) {\n      continue\n    }\n\n    // `resolveMigrationScript` may return several loadable candidates for a\n    // single id (e.g. both `foo.ts` and `foo/index.ts`). List it just once.\n    const candidate = (await resolveMigrationScript(workDir, entryName)).find((script) =>\n      isLoadableMigrationScript(script),\n    )\n    if (candidate) {\n      seen.add(entryName)\n      migrations.push({id: entryName, migration: candidate.mod.default})\n    }\n  }\n\n  return migrations\n}\n"],"names":["readdir","path","MIGRATION_SCRIPT_EXTENSIONS","MIGRATIONS_DIRECTORY","isLoadableMigrationScript","resolveMigrationScript","removeMigrationScriptExtension","fileName","ext","find","e","endsWith","basename","resolveMigrations","workDir","migrationsDir","join","migrationEntries","withFileTypes","migrations","seen","Set","entry","entryName","isDirectory","name","has","candidate","script","add","push","id","migration","mod","default"],"mappings":"AAAA,SAAQA,OAAO,QAAO,mBAAkB;AACxC,OAAOC,UAAU,YAAW;AAI5B,SAAQC,2BAA2B,EAAEC,oBAAoB,QAAO,iBAAgB;AAChF,SAAQC,yBAAyB,EAAEC,sBAAsB,QAAO,8BAA6B;AAY7F;;;;;;CAMC,GACD,SAASC,+BAA+BC,QAAgB;IACtD,qDAAqD;IACrD,MAAMC,MAAMN,4BAA4BO,IAAI,CAAC,CAACC,IAAMH,SAASI,QAAQ,CAAC,CAAC,CAAC,EAAED,GAAG;IAC7E,OAAOF,MAAMP,KAAKW,QAAQ,CAACL,UAAU,CAAC,CAAC,EAAEC,KAAK,IAAID;AACpD;AAEA;;;;;;CAMC,GACD,OAAO,eAAeM,kBAAkBC,OAAe;IACrD,MAAMC,gBAAgBd,KAAKe,IAAI,CAACF,SAASX;IACzC,MAAMc,mBAAmB,MAAMjB,QAAQe,eAAe;QAACG,eAAe;IAAI;IAE1E,MAAMC,aAAkC,EAAE;IAC1C,MAAMC,OAAO,IAAIC;IACjB,KAAK,MAAMC,SAASL,iBAAkB;QACpC,MAAMM,YAAYD,MAAME,WAAW,KAAKF,MAAMG,IAAI,GAAGnB,+BAA+BgB,MAAMG,IAAI;QAC9F,2EAA2E;QAC3E,sCAAsC;QACtC,IAAIL,KAAKM,GAAG,CAACH,YAAY;YACvB;QACF;QAEA,wEAAwE;QACxE,wEAAwE;QACxE,MAAMI,YAAY,AAAC,CAAA,MAAMtB,uBAAuBS,SAASS,UAAS,EAAGd,IAAI,CAAC,CAACmB,SACzExB,0BAA0BwB;QAE5B,IAAID,WAAW;YACbP,KAAKS,GAAG,CAACN;YACTJ,WAAWW,IAAI,CAAC;gBAACC,IAAIR;gBAAWS,WAAWL,UAAUM,GAAG,CAACC,OAAO;YAAA;QAClE;IACF;IAEA,OAAOf;AACT"}

package/dist/actions/migration/templates/index.js

@@ -0,0 +1,7 @@
+export { minimalAdvanced } from './minimalAdvanced.js';
+export { minimalSimple } from './minimalSimple.js';
+export { renameField } from './renameField.js';
+export { renameType } from './renameType.js';
+export { stringToPTE } from './stringToPTE.js';
+
+//# sourceMappingURL=index.js.map

package/dist/actions/migration/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/index.ts"],"sourcesContent":["export {minimalAdvanced} from './minimalAdvanced.js'\nexport {minimalSimple} from './minimalSimple.js'\nexport {renameField} from './renameField.js'\nexport {renameType} from './renameType.js'\nexport {stringToPTE} from './stringToPTE.js'\n"],"names":["minimalAdvanced","minimalSimple","renameField","renameType","stringToPTE"],"mappings":"AAAA,SAAQA,eAAe,QAAO,uBAAsB;AACpD,SAAQC,aAAa,QAAO,qBAAoB;AAChD,SAAQC,WAAW,QAAO,mBAAkB;AAC5C,SAAQC,UAAU,QAAO,kBAAiB;AAC1C,SAAQC,WAAW,QAAO,mBAAkB"}

package/dist/actions/migration/templates/minimalAdvanced.js

@@ -0,0 +1,21 @@
+export const minimalAdvanced = ({ documentTypes, migrationName })=>`import {defineMigration, patch, at, setIfMissing} from 'sanity/migrate'
+
+/**
+ * this migration will set \`Default title\` on all documents that are missing a title
+ * and make \`true\` the default value for the \`enabled\` field
+ */
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  async *migrate(documents, context) {
+    for await (const document of documents()) {
+      yield patch(document._id, [
+        at('title', setIfMissing('Default title')),
+        at('enabled', setIfMissing(true)),
+      ])
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=minimalAdvanced.js.map

package/dist/actions/migration/templates/minimalAdvanced.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/minimalAdvanced.ts"],"sourcesContent":["export const minimalAdvanced = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, patch, at, setIfMissing} from 'sanity/migrate'\n\n/**\n * this migration will set \\`Default title\\` on all documents that are missing a title\n * and make \\`true\\` the default value for the \\`enabled\\` field\n */\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  async *migrate(documents, context) {\n    for await (const document of documents()) {\n      yield patch(document._id, [\n        at('title', setIfMissing('Default title')),\n        at('enabled', setIfMissing(true)),\n      ])\n    }\n  }\n})\n`\n"],"names":["minimalAdvanced","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,kBAAkB,CAAC,EAC9BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;;SAOE,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;AAUD,CAAC,CAAA"}

package/dist/actions/migration/templates/minimalSimple.js

@@ -0,0 +1,61 @@
+export const minimalSimple = ({ documentTypes, migrationName })=>`import {at, defineMigration, setIfMissing, unset} from 'sanity/migrate'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    document(doc, context) {
+      // this will be called for every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+
+      return at('title', setIfMissing('Default title'))
+    },
+    node(node, path, context) {
+      // this will be called for every node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+
+      if (typeof node === 'string' && node === 'deleteme') {
+        return unset()
+      }
+    },
+    object(node, path, context) {
+      // this will be called for every object node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+      if (node._type === 'author') {
+        // make sure all authors objects have a books array
+        return at('books', setIfMissing([]))
+      }
+    },
+    array(node, path, context) {
+      // this will be called for every array node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    string(node, path, context) {
+      // this will be called for every string node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    number(node, path, context) {
+      // this will be called for every number node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    boolean(node, path, context) {
+      // this will be called for every boolean node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    null(node, path, context) {
+      // this will be called for every null node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+  },
+})
+`;
+
+//# sourceMappingURL=minimalSimple.js.map

package/dist/actions/migration/templates/minimalSimple.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/minimalSimple.ts"],"sourcesContent":["export const minimalSimple = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {at, defineMigration, setIfMissing, unset} from 'sanity/migrate'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    document(doc, context) {\n      // this will be called for every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n\n      return at('title', setIfMissing('Default title'))\n    },\n    node(node, path, context) {\n      // this will be called for every node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n\n      if (typeof node === 'string' && node === 'deleteme') {\n        return unset()\n      }\n    },\n    object(node, path, context) {\n      // this will be called for every object node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n      if (node._type === 'author') {\n        // make sure all authors objects have a books array\n        return at('books', setIfMissing([]))\n      }\n    },\n    array(node, path, context) {\n      // this will be called for every array node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    string(node, path, context) {\n      // this will be called for every string node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    number(node, path, context) {\n      // this will be called for every number node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    boolean(node, path, context) {\n      // this will be called for every boolean node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    null(node, path, context) {\n      // this will be called for every null node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n  },\n})\n`\n"],"names":["minimalSimple","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,gBAAgB,CAAC,EAC5BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;SAGE,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,CAAC,CAAA"}

package/dist/actions/migration/templates/renameField.js

@@ -0,0 +1,20 @@
+export const renameField = ({ documentTypes, migrationName })=>`import {defineMigration, at, setIfMissing, unset} from 'sanity/migrate'
+
+const from = 'oldFieldName'
+const to = 'newFieldName'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    document(doc, context) {
+      return [
+        at(to, setIfMissing(doc[from])),
+        at(from, unset())
+      ]
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=renameField.js.map

package/dist/actions/migration/templates/renameField.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/renameField.ts"],"sourcesContent":["export const renameField = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, at, setIfMissing, unset} from 'sanity/migrate'\n\nconst from = 'oldFieldName'\nconst to = 'newFieldName'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    document(doc, context) {\n      return [\n        at(to, setIfMissing(doc[from])),\n        at(from, unset())\n      ]\n    }\n  }\n})\n`\n"],"names":["renameField","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,cAAc,CAAC,EAC1BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;AAUD,CAAC,CAAA"}

package/dist/actions/migration/templates/renameType.js

@@ -0,0 +1,19 @@
+export const renameType = ({ documentTypes, migrationName })=>`import {defineMigration, at, set} from 'sanity/migrate'
+
+const oldType = 'old'
+const newType = 'new'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    object(object, path, context) {
+      if (object._type === oldType) {
+        return at('_type', set(newType))
+      }
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=renameType.js.map

package/dist/actions/migration/templates/renameType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/renameType.ts"],"sourcesContent":["export const renameType = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, at, set} from 'sanity/migrate'\n\nconst oldType = 'old'\nconst newType = 'new'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    object(object, path, context) {\n      if (object._type === oldType) {\n        return at('_type', set(newType))\n      }\n    }\n  }\n})\n`\n"],"names":["renameType","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,aAAa,CAAC,EACzBC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;AASD,CAAC,CAAA"}

package/dist/actions/migration/templates/stringToPTE.js

@@ -0,0 +1,32 @@
+export const stringToPTE = ({ documentTypes, migrationName })=>`import {pathsAreEqual, stringToPath} from 'sanity'
+import {defineMigration, set} from 'sanity/migrate'
+
+const targetPath = stringToPath('some.path')
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    string(node, path, ctx) {
+      if (pathsAreEqual(path, targetPath)) {
+        return set([
+          {
+            style: 'normal',
+            _type: 'block',
+            children: [
+              {
+                _type: 'span',
+                marks: [],
+                text: node,
+              },
+            ],
+            markDefs: [],
+          },
+        ])
+      }
+    },
+  },
+})
+`;
+
+//# sourceMappingURL=stringToPTE.js.map

package/dist/actions/migration/templates/stringToPTE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/stringToPTE.ts"],"sourcesContent":["export const stringToPTE = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {pathsAreEqual, stringToPath} from 'sanity'\nimport {defineMigration, set} from 'sanity/migrate'\n\nconst targetPath = stringToPath('some.path')\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    string(node, path, ctx) {\n      if (pathsAreEqual(path, targetPath)) {\n        return set([\n          {\n            style: 'normal',\n            _type: 'block',\n            children: [\n              {\n                _type: 'span',\n                marks: [],\n                text: node,\n              },\n            ],\n            markDefs: [],\n          },\n        ])\n      }\n    },\n  },\n})\n`\n"],"names":["stringToPTE","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,cAAc,CAAC,EAC1BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;;;;;;;;;;;;;AAsBD,CAAC,CAAA"}