@sanity/cli 5.9.0-next.8 → 6.0.0-alpha.11

package/dist/actions/init/updateInitialTemplateMetadata.js

@@ -0,0 +1,17 @@
+import { subdebug } from '@sanity/cli-core';
+import { updateProjectInitalTemplate } from '../../services/projects.js';
+const debug = subdebug('init:updateInitialTemplateMetadata');
+export async function updateInitialTemplateMetadata(projectId, templateName) {
+    try {
+        await updateProjectInitalTemplate(projectId, templateName);
+    } catch (err) {
+        // Non-critical that we update this metadata, and user does not need to be aware
+        let message = typeof err === 'string' ? err : '<unknown error>';
+        if (err instanceof Error) {
+            message = err.message;
+        }
+        debug('Failed to update initial template metadata for project: %s', message);
+    }
+}
+
+//# sourceMappingURL=updateInitialTemplateMetadata.js.map

package/dist/actions/init/updateInitialTemplateMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/init/updateInitialTemplateMetadata.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nimport {updateProjectInitalTemplate} from '../../services/projects.js'\n\nconst debug = subdebug('init:updateInitialTemplateMetadata')\n\nexport async function updateInitialTemplateMetadata(\n  projectId: string,\n  templateName: string,\n): Promise<void> {\n  try {\n    await updateProjectInitalTemplate(projectId, templateName)\n  } catch (err: unknown) {\n    // Non-critical that we update this metadata, and user does not need to be aware\n    let message = typeof err === 'string' ? err : '<unknown error>'\n    if (err instanceof Error) {\n      message = err.message\n    }\n\n    debug('Failed to update initial template metadata for project: %s', message)\n  }\n}\n"],"names":["subdebug","updateProjectInitalTemplate","debug","updateInitialTemplateMetadata","projectId","templateName","err","message","Error"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,SAAQC,2BAA2B,QAAO,6BAA4B;AAEtE,MAAMC,QAAQF,SAAS;AAEvB,OAAO,eAAeG,8BACpBC,SAAiB,EACjBC,YAAoB;IAEpB,IAAI;QACF,MAAMJ,4BAA4BG,WAAWC;IAC/C,EAAE,OAAOC,KAAc;QACrB,gFAAgF;QAChF,IAAIC,UAAU,OAAOD,QAAQ,WAAWA,MAAM;QAC9C,IAAIA,eAAeE,OAAO;YACxBD,UAAUD,IAAIC,OAAO;QACvB;QAEAL,MAAM,8DAA8DK;IACtE;AACF"}

package/dist/actions/manifest/SchemaIcon.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ThemeProvider } from '@sanity/ui';
+import { buildTheme } from '@sanity/ui/theme';
+import { isValidElement } from 'react';
+import { isValidElementType } from 'react-is';
+import { createDefaultIcon } from 'sanity';
+const theme = buildTheme();
+const SchemaIcon = ({ icon, subtitle, title })=>{
+    return /*#__PURE__*/ _jsx(ThemeProvider, {
+        theme: theme,
+        children: normalizeIcon(icon, title, subtitle)
+    });
+};
+function normalizeIcon(Icon, title, subtitle = '') {
+    if (isValidElementType(Icon)) return /*#__PURE__*/ _jsx(Icon, {});
+    if (/*#__PURE__*/ isValidElement(Icon)) return Icon;
+    return createDefaultIcon(title, subtitle);
+}
+export { SchemaIcon };
+
+//# sourceMappingURL=SchemaIcon.js.map

package/dist/actions/manifest/SchemaIcon.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/manifest/SchemaIcon.tsx"],"sourcesContent":["import {ThemeProvider} from '@sanity/ui'\nimport {buildTheme} from '@sanity/ui/theme'\nimport {type ComponentType, isValidElement, type ReactNode} from 'react'\nimport {isValidElementType} from 'react-is'\nimport {createDefaultIcon} from 'sanity'\n\nconst theme = buildTheme()\n\ninterface SchemaIconProps {\n  title: string\n\n  icon?: ComponentType | ReactNode\n  subtitle?: string\n}\n\nconst SchemaIcon = ({icon, subtitle, title}: SchemaIconProps): React.JSX.Element => {\n  return <ThemeProvider theme={theme}>{normalizeIcon(icon, title, subtitle)}</ThemeProvider>\n}\n\nfunction normalizeIcon(\n  Icon: ComponentType | ReactNode | undefined,\n  title: string,\n  subtitle = '',\n): React.JSX.Element {\n  if (isValidElementType(Icon)) return <Icon />\n  if (isValidElement(Icon)) return Icon\n  return createDefaultIcon(title, subtitle)\n}\n\nexport {SchemaIcon}\nexport type {SchemaIconProps}\n"],"names":["ThemeProvider","buildTheme","isValidElement","isValidElementType","createDefaultIcon","theme","SchemaIcon","icon","subtitle","title","normalizeIcon","Icon"],"mappings":";AAAA,SAAQA,aAAa,QAAO,aAAY;AACxC,SAAQC,UAAU,QAAO,mBAAkB;AAC3C,SAA4BC,cAAc,QAAuB,QAAO;AACxE,SAAQC,kBAAkB,QAAO,WAAU;AAC3C,SAAQC,iBAAiB,QAAO,SAAQ;AAExC,MAAMC,QAAQJ;AASd,MAAMK,aAAa,CAAC,EAACC,IAAI,EAAEC,QAAQ,EAAEC,KAAK,EAAkB;IAC1D,qBAAO,KAACT;QAAcK,OAAOA;kBAAQK,cAAcH,MAAME,OAAOD;;AAClE;AAEA,SAASE,cACPC,IAA2C,EAC3CF,KAAa,EACbD,WAAW,EAAE;IAEb,IAAIL,mBAAmBQ,OAAO,qBAAO,KAACA;IACtC,kBAAIT,eAAeS,OAAO,OAAOA;IACjC,OAAOP,kBAAkBK,OAAOD;AAClC;AAEA,SAAQF,UAAU,GAAC"}

package/dist/actions/manifest/extractAppManifest.js

@@ -0,0 +1,51 @@
+import { getCliConfig } from '@sanity/cli-core';
+import { spinner } from '@sanity/cli-core/ux';
+import { getErrorMessage } from '../../util/getErrorMessage.js';
+/**
+ *
+ * This functions slightly differently from the studio manifest extraction function.
+ * We don't need to parse very complicated information like schemas and tools,
+ * and we submit the manifest as a multipart form field instead of writing a file.
+ */ export async function extractAppManifest(options) {
+    const { workDir } = options;
+    const spin = spinner('Extracting manifest').start();
+    try {
+        const { app } = await getCliConfig(workDir);
+        if (!app) {
+            // this is probably a problem for deployment, but not an issue for manifest extraction
+            spin.succeed('No app configuration found');
+            return undefined;
+        }
+        const manifest = {
+            version: '1',
+            ...app.icon ? {
+                icon: app.icon
+            } : {},
+            ...app.title ? {
+                title: app.title
+            } : {}
+        };
+        spin.succeed(`Extracted manifest`);
+        return manifest;
+    } catch (err) {
+        const message = getErrorMessage(err);
+        spin.fail(message);
+        throw err;
+    }
+}
+/**
+ * App manifests aren't required right now.
+ * This function just ensures we're not uploading empty manifests
+ * (so we can reduce noise in user-applications)
+ */ export function appManifestHasData(manifest) {
+    if (!manifest || typeof manifest !== 'object' || Object.keys(manifest).length === 0) {
+        return false;
+    }
+    const validAppManifestKeys = [
+        'icon',
+        'title'
+    ];
+    return validAppManifestKeys.some((key)=>!!manifest[key]);
+}
+
+//# sourceMappingURL=extractAppManifest.js.map

package/dist/actions/manifest/extractAppManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/manifest/extractAppManifest.ts"],"sourcesContent":["import {getCliConfig} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\n\nimport {getErrorMessage} from '../../util/getErrorMessage.js'\nimport {type DeployFlags} from '../deploy/types.js'\nimport {type AppManifest} from './types.js'\n\ninterface ExtractAppManifestOptions {\n  flags: DeployFlags\n  workDir: string\n}\n\n/**\n *\n * This functions slightly differently from the studio manifest extraction function.\n * We don't need to parse very complicated information like schemas and tools,\n * and we submit the manifest as a multipart form field instead of writing a file.\n */\nexport async function extractAppManifest(options: ExtractAppManifestOptions): Promise<AppManifest | undefined> {\n  const {workDir} = options\n\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    const {app} = await getCliConfig(workDir)\n    if (!app) {\n      // this is probably a problem for deployment, but not an issue for manifest extraction\n      spin.succeed('No app configuration found')\n      return undefined\n    }\n    const manifest: AppManifest = {\n      version: '1',\n      ...(app.icon ? {icon: app.icon} : {}),\n      ...(app.title ? {title: app.title} : {}),\n    }\n\n    spin.succeed(`Extracted manifest`)\n\n    return manifest\n  } catch (err) {\n    const message = getErrorMessage(err)\n    spin.fail(message)\n    throw err\n  }\n}\n\n/**\n * App manifests aren't required right now.\n * This function just ensures we're not uploading empty manifests\n * (so we can reduce noise in user-applications)\n */\nexport function appManifestHasData(manifest?: AppManifest | null): boolean {\n  if (!manifest || typeof manifest !== 'object' || Object.keys(manifest).length === 0) {\n    return false\n  }\n  const validAppManifestKeys = ['icon', 'title']\n  return validAppManifestKeys.some((key) => !!manifest[key as keyof AppManifest])\n}\n"],"names":["getCliConfig","spinner","getErrorMessage","extractAppManifest","options","workDir","spin","start","app","succeed","undefined","manifest","version","icon","title","err","message","fail","appManifestHasData","Object","keys","length","validAppManifestKeys","some","key"],"mappings":"AAAA,SAAQA,YAAY,QAAO,mBAAkB;AAC7C,SAAQC,OAAO,QAAO,sBAAqB;AAE3C,SAAQC,eAAe,QAAO,gCAA+B;AAS7D;;;;;CAKC,GACD,OAAO,eAAeC,mBAAmBC,OAAkC;IACzE,MAAM,EAACC,OAAO,EAAC,GAAGD;IAElB,MAAME,OAAOL,QAAQ,uBAAuBM,KAAK;IAEjD,IAAI;QACF,MAAM,EAACC,GAAG,EAAC,GAAG,MAAMR,aAAaK;QACjC,IAAI,CAACG,KAAK;YACR,sFAAsF;YACtFF,KAAKG,OAAO,CAAC;YACb,OAAOC;QACT;QACA,MAAMC,WAAwB;YAC5BC,SAAS;YACT,GAAIJ,IAAIK,IAAI,GAAG;gBAACA,MAAML,IAAIK,IAAI;YAAA,IAAI,CAAC,CAAC;YACpC,GAAIL,IAAIM,KAAK,GAAG;gBAACA,OAAON,IAAIM,KAAK;YAAA,IAAI,CAAC,CAAC;QACzC;QAEAR,KAAKG,OAAO,CAAC,CAAC,kBAAkB,CAAC;QAEjC,OAAOE;IACT,EAAE,OAAOI,KAAK;QACZ,MAAMC,UAAUd,gBAAgBa;QAChCT,KAAKW,IAAI,CAACD;QACV,MAAMD;IACR;AACF;AAEA;;;;CAIC,GACD,OAAO,SAASG,mBAAmBP,QAA6B;IAC9D,IAAI,CAACA,YAAY,OAAOA,aAAa,YAAYQ,OAAOC,IAAI,CAACT,UAAUU,MAAM,KAAK,GAAG;QACnF,OAAO;IACT;IACA,MAAMC,uBAAuB;QAAC;QAAQ;KAAQ;IAC9C,OAAOA,qBAAqBC,IAAI,CAAC,CAACC,MAAQ,CAAC,CAACb,QAAQ,CAACa,IAAyB;AAChF"}

package/dist/actions/manifest/extractManifest.js

@@ -0,0 +1,93 @@
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { getTimer } from '@sanity/cli-core';
+import { spinner } from '@sanity/cli-core/ux';
+import { importStudioConfig } from '../../util/importStudioConfig.js';
+import { readModuleVersion } from '../../util/readModuleVersion.js';
+import { extractWorkspaceManifest } from './extractWorkspaceManifest.js';
+export const MANIFEST_FILENAME = 'create-manifest.json';
+const SCHEMA_FILENAME_SUFFIX = '.create-schema.json';
+const TOOLS_FILENAME_SUFFIX = '.create-tools.json';
+/** Escape-hatch env flags to change action behavior */ const FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_EXTRACT_MANIFEST_ENABLED';
+const EXTRACT_MANIFEST_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] !== 'false';
+const EXTRACT_MANIFEST_LOG_ERRORS = process.env.SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS === 'true';
+const CREATE_TIMER = 'create-manifest';
+/**
+ * This function will never throw.
+ * @returns `undefined` if extract succeeded - caught error if it failed
+ */ export async function extractManifestSafe(options) {
+    if (!EXTRACT_MANIFEST_ENABLED) {
+        return undefined;
+    }
+    try {
+        await extractManifest(options);
+        return undefined;
+    } catch (err) {
+        if (EXTRACT_MANIFEST_LOG_ERRORS) {
+            options.output.error(err);
+        }
+        return err;
+    }
+}
+async function extractManifest(options) {
+    const { flags, workDir } = options;
+    const staticPath = resolve(join(workDir, flags.path));
+    const path = join(staticPath, MANIFEST_FILENAME);
+    const timer = getTimer();
+    timer.start(CREATE_TIMER);
+    const spin = spinner('Extracting manifest').start();
+    try {
+        const workspaceManifests = await getWorkspaceManifests(workDir);
+        await mkdir(staticPath, {
+            recursive: true
+        });
+        const workspaceFiles = await writeWorkspaceFiles(workspaceManifests, staticPath);
+        const manifest = {
+            /**
+       * Version history:
+       * 1: Initial release.
+       * 2: Added tools file.
+       * 3. Added studioVersion field.
+       */ createdAt: new Date().toISOString(),
+            studioVersion: await readModuleVersion(workDir, 'sanity'),
+            version: 3,
+            workspaces: workspaceFiles
+        };
+        await writeFile(path, JSON.stringify(manifest, null, 2));
+        const manifestDuration = timer.end(CREATE_TIMER);
+        spin.succeed(`Extracted manifest (${manifestDuration.toFixed(0)}ms)`);
+    } catch (err) {
+        spin.fail(err.message);
+        throw err;
+    }
+}
+async function getWorkspaceManifests(workDir) {
+    const workspaces = await importStudioConfig(workDir);
+    return await extractWorkspaceManifest(workspaces);
+}
+function writeWorkspaceFiles(manifestWorkspaces, staticPath) {
+    const output = manifestWorkspaces.map((workspace)=>writeWorkspaceFile(workspace, staticPath));
+    return Promise.all(output);
+}
+async function writeWorkspaceFile(workspace, staticPath) {
+    const [schemaFilename, toolsFilename] = await Promise.all([
+        createFile(staticPath, workspace.schema, SCHEMA_FILENAME_SUFFIX),
+        createFile(staticPath, workspace.tools, TOOLS_FILENAME_SUFFIX)
+    ]);
+    return {
+        ...workspace,
+        schema: schemaFilename,
+        tools: toolsFilename
+    };
+}
+const createFile = async (path, content, filenameSuffix)=>{
+    const stringifiedContent = JSON.stringify(content, null, 2);
+    const hash = createHash('sha1').update(stringifiedContent).digest('hex');
+    const filename = `${hash.slice(0, 8)}${filenameSuffix}`;
+    // workspaces with identical data will overwrite each others file. This is ok, since they are identical and can be shared
+    await writeFile(join(path, filename), stringifiedContent);
+    return filename;
+};
+
+//# sourceMappingURL=extractManifest.js.map

package/dist/actions/manifest/extractManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/manifest/extractManifest.ts"],"sourcesContent":["import {createHash} from 'node:crypto'\nimport {mkdir, writeFile} from 'node:fs/promises'\nimport {join, resolve} from 'node:path'\n\nimport {getTimer, Output} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport {type Workspace} from 'sanity'\n\nimport {type ExtractManifestCommand} from '../../commands/manifest/extract'\nimport {importStudioConfig} from '../../util/importStudioConfig.js'\nimport {readModuleVersion} from '../../util/readModuleVersion.js'\nimport {extractWorkspaceManifest} from './extractWorkspaceManifest.js'\nimport {\n  type CreateManifest,\n  type CreateWorkspaceManifest,\n  type ManifestWorkspaceFile,\n} from './types'\n\nexport const MANIFEST_FILENAME = 'create-manifest.json'\nconst SCHEMA_FILENAME_SUFFIX = '.create-schema.json'\nconst TOOLS_FILENAME_SUFFIX = '.create-tools.json'\n\n/** Escape-hatch env flags to change action behavior */\nconst FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_EXTRACT_MANIFEST_ENABLED'\nconst EXTRACT_MANIFEST_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] !== 'false'\nconst EXTRACT_MANIFEST_LOG_ERRORS = process.env.SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS === 'true'\n\nconst CREATE_TIMER = 'create-manifest'\n\ninterface ExtractManifestOptions {\n  flags: ExtractManifestCommand['flags']\n  output: Output\n  workDir: string\n}\n\n/**\n * This function will never throw.\n * @returns `undefined` if extract succeeded - caught error if it failed\n */\nexport async function extractManifestSafe(\n  options: ExtractManifestOptions,\n): Promise<Error | undefined> {\n  if (!EXTRACT_MANIFEST_ENABLED) {\n    return undefined\n  }\n\n  try {\n    await extractManifest(options)\n    return undefined\n  } catch (err) {\n    if (EXTRACT_MANIFEST_LOG_ERRORS) {\n      options.output.error(err)\n    }\n    return err\n  }\n}\n\nasync function extractManifest(options: ExtractManifestOptions): Promise<void> {\n  const {flags, workDir} = options\n  const staticPath = resolve(join(workDir, flags.path))\n  const path = join(staticPath, MANIFEST_FILENAME)\n\n  const timer = getTimer()\n  timer.start(CREATE_TIMER)\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    const workspaceManifests = await getWorkspaceManifests(workDir)\n    await mkdir(staticPath, {recursive: true})\n\n    const workspaceFiles = await writeWorkspaceFiles(workspaceManifests, staticPath)\n\n    const manifest: CreateManifest = {\n      /**\n       * Version history:\n       * 1: Initial release.\n       * 2: Added tools file.\n       * 3. Added studioVersion field.\n       */\n      createdAt: new Date().toISOString(),\n      studioVersion: await readModuleVersion(workDir, 'sanity'),\n      version: 3,\n      workspaces: workspaceFiles,\n    }\n\n    await writeFile(path, JSON.stringify(manifest, null, 2))\n    const manifestDuration = timer.end(CREATE_TIMER)\n\n    spin.succeed(`Extracted manifest (${manifestDuration.toFixed(0)}ms)`)\n  } catch (err) {\n    spin.fail(err.message)\n    throw err\n  }\n}\n\nasync function getWorkspaceManifests(workDir: string): Promise<CreateWorkspaceManifest[]> {\n  const workspaces = await importStudioConfig(workDir)\n  return await extractWorkspaceManifest(workspaces as unknown as Workspace[])\n}\n\nfunction writeWorkspaceFiles(\n  manifestWorkspaces: CreateWorkspaceManifest[],\n  staticPath: string,\n): Promise<ManifestWorkspaceFile[]> {\n  const output = manifestWorkspaces.map((workspace) => writeWorkspaceFile(workspace, staticPath))\n\n  return Promise.all(output)\n}\n\nasync function writeWorkspaceFile(\n  workspace: CreateWorkspaceManifest,\n  staticPath: string,\n): Promise<ManifestWorkspaceFile> {\n  const [schemaFilename, toolsFilename] = await Promise.all([\n    createFile(staticPath, workspace.schema, SCHEMA_FILENAME_SUFFIX),\n    createFile(staticPath, workspace.tools, TOOLS_FILENAME_SUFFIX),\n  ])\n\n  return {\n    ...workspace,\n    schema: schemaFilename,\n    tools: toolsFilename,\n  }\n}\n\nconst createFile = async (path: string, content: unknown, filenameSuffix: string) => {\n  const stringifiedContent = JSON.stringify(content, null, 2)\n  const hash = createHash('sha1').update(stringifiedContent).digest('hex')\n  const filename = `${hash.slice(0, 8)}${filenameSuffix}`\n\n  // workspaces with identical data will overwrite each others file. This is ok, since they are identical and can be shared\n  await writeFile(join(path, filename), stringifiedContent)\n\n  return filename\n}\n"],"names":["createHash","mkdir","writeFile","join","resolve","getTimer","spinner","importStudioConfig","readModuleVersion","extractWorkspaceManifest","MANIFEST_FILENAME","SCHEMA_FILENAME_SUFFIX","TOOLS_FILENAME_SUFFIX","FEATURE_ENABLED_ENV_NAME","EXTRACT_MANIFEST_ENABLED","process","env","EXTRACT_MANIFEST_LOG_ERRORS","SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS","CREATE_TIMER","extractManifestSafe","options","undefined","extractManifest","err","output","error","flags","workDir","staticPath","path","timer","start","spin","workspaceManifests","getWorkspaceManifests","recursive","workspaceFiles","writeWorkspaceFiles","manifest","createdAt","Date","toISOString","studioVersion","version","workspaces","JSON","stringify","manifestDuration","end","succeed","toFixed","fail","message","manifestWorkspaces","map","workspace","writeWorkspaceFile","Promise","all","schemaFilename","toolsFilename","createFile","schema","tools","content","filenameSuffix","stringifiedContent","hash","update","digest","filename","slice"],"mappings":"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"}

package/dist/actions/manifest/extractWorkspaceManifest.js

@@ -0,0 +1,406 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DOMPurify from 'isomorphic-dompurify';
+import startCase from 'lodash-es/startCase.js';
+import { renderToString } from 'react-dom/server';
+import { ConcreteRuleClass, createSchema } from 'sanity';
+import { ServerStyleSheet } from 'styled-components';
+import { config } from './purifyConfig.js';
+import { SchemaIcon } from './SchemaIcon.js';
+import { getCustomFields, getDefinedTypeName, isCrossDatasetReference, isCustomized, isDefined, isGlobalDocumentReference, isPrimitive, isRecord, isReference, isString, isType } from './schemaTypeHelpers.js';
+const MAX_CUSTOM_PROPERTY_DEPTH = 5;
+export function extractWorkspaceManifest(workspaces) {
+    return workspaces.map((workspace)=>{
+        const serializedSchema = extractManifestSchemaTypes(workspace.schema);
+        const serializedTools = extractManifestTools(workspace.tools);
+        return {
+            basePath: workspace.basePath,
+            dataset: workspace.dataset,
+            icon: resolveIcon({
+                icon: workspace.icon,
+                subtitle: workspace.subtitle,
+                title: workspace.title
+            }),
+            mediaLibrary: workspace.mediaLibrary,
+            name: workspace.name,
+            projectId: workspace.projectId,
+            schema: serializedSchema,
+            subtitle: workspace.subtitle,
+            title: workspace.title,
+            tools: serializedTools
+        };
+    });
+}
+/**
+ * Extracts all serializable properties from userland schema types,
+ * so they best-effort can be used as definitions for Schema.compile
+. */ function extractManifestSchemaTypes(schema) {
+    const typeNames = schema.getTypeNames();
+    const context = {
+        schema
+    };
+    const studioDefaultTypeNames = createSchema({
+        name: 'default',
+        types: []
+    }).getTypeNames();
+    return typeNames.filter((typeName)=>!studioDefaultTypeNames.includes(typeName)).map((typeName)=>schema.get(typeName)).filter((type)=>type !== undefined).map((type)=>transformType(type, context));
+}
+function transformCommonTypeFields(type, typeName, context) {
+    const arrayProps = typeName === 'array' && type.jsonType === 'array' ? transformArrayMember(type, context) : {};
+    const referenceProps = isReference(type) ? transformReference(type) : {};
+    const crossDatasetRefProps = isCrossDatasetReference(type) ? transformCrossDatasetReference(type) : {};
+    const globalRefProps = isGlobalDocumentReference(type) ? transformGlobalDocumentReference(type) : {};
+    const objectFields = type.jsonType === 'object' && type.type && isCustomized(type) ? {
+        fields: getCustomFields(type).map((objectField)=>transformField(objectField, context))
+    } : {};
+    return {
+        ...retainCustomTypeProps(type),
+        ...transformValidation(type.validation),
+        ...ensureString('description', type.description),
+        ...objectFields,
+        ...arrayProps,
+        ...referenceProps,
+        ...crossDatasetRefProps,
+        ...globalRefProps,
+        ...ensureConditional('readOnly', type.readOnly),
+        ...ensureConditional('hidden', type.hidden),
+        ...transformFieldsets(type),
+        // fieldset prop gets instrumented via getCustomFields
+        ...ensureString('fieldset', type.fieldset),
+        ...transformBlockType(type, context)
+    };
+}
+function transformFieldsets(type) {
+    if (type.jsonType !== 'object') {
+        return {};
+    }
+    const fieldsets = type.fieldsets?.filter((fs)=>!fs.single).map((fs)=>{
+        const options = isRecord(fs.options) ? {
+            options: retainSerializableProps(fs.options)
+        } : {};
+        return {
+            name: fs.name,
+            ...ensureCustomTitle(fs.name, fs.title),
+            ...ensureString('description', fs.description),
+            ...ensureConditional('readOnly', fs.readOnly),
+            ...ensureConditional('hidden', fs.hidden),
+            ...options
+        };
+    });
+    return fieldsets?.length ? {
+        fieldsets
+    } : {};
+}
+function transformType(type, context) {
+    const typeName = type.type ? type.type.name : type.jsonType;
+    return {
+        ...transformCommonTypeFields(type, typeName, context),
+        name: type.name,
+        type: typeName,
+        ...ensureCustomTitle(type.name, type.title)
+    };
+}
+function retainCustomTypeProps(type) {
+    const manuallySerializedFields = new Set([
+        '__experimental_actions',
+        '__experimental_formPreviewTitle',
+        '__experimental_omnisearch_visibility',
+        '__experimental_search',
+        'components',
+        'description',
+        'fields',
+        'fieldsets',
+        //only exists on fields
+        'group',
+        'groups',
+        'hidden',
+        'icon',
+        'jsonType',
+        //explicitly added
+        'name',
+        'of',
+        'orderings',
+        'preview',
+        'readOnly',
+        'title',
+        'to',
+        // not serialized
+        'type',
+        'validation'
+    ]);
+    const typeWithoutManuallyHandledFields = Object.fromEntries(Object.entries(type).filter(([key])=>!manuallySerializedFields.has(key)));
+    return retainSerializableProps(typeWithoutManuallyHandledFields);
+}
+function retainSerializableProps(maybeSerializable, depth = 0) {
+    if (depth > MAX_CUSTOM_PROPERTY_DEPTH) {
+        return undefined;
+    }
+    if (!isDefined(maybeSerializable)) {
+        return undefined;
+    }
+    if (isPrimitive(maybeSerializable)) {
+        // cull empty strings
+        if (maybeSerializable === '') {
+            return undefined;
+        }
+        return maybeSerializable;
+    }
+    // url-schemes ect..
+    if (maybeSerializable instanceof RegExp) {
+        return maybeSerializable.toString();
+    }
+    if (Array.isArray(maybeSerializable)) {
+        const arrayItems = maybeSerializable.map((item)=>retainSerializableProps(item, depth + 1)).filter((item)=>isDefined(item));
+        return arrayItems.length > 0 ? arrayItems : undefined;
+    }
+    if (isRecord(maybeSerializable)) {
+        const serializableEntries = Object.entries(maybeSerializable).map(([key, value])=>{
+            return [
+                key,
+                retainSerializableProps(value, depth + 1)
+            ];
+        }).filter(([, value])=>isDefined(value));
+        return serializableEntries.length > 0 ? Object.fromEntries(serializableEntries) : undefined;
+    }
+    return undefined;
+}
+function transformField(field, context) {
+    const fieldType = field.type;
+    const typeName = getDefinedTypeName(fieldType) ?? fieldType.name;
+    return {
+        ...transformCommonTypeFields(fieldType, typeName, context),
+        name: field.name,
+        type: typeName,
+        ...ensureCustomTitle(field.name, fieldType.title),
+        // this prop gets added synthetically via getCustomFields
+        ...ensureString('fieldset', field.fieldset)
+    };
+}
+function transformArrayMember(arrayMember, context) {
+    return {
+        of: arrayMember.of.map((type)=>{
+            const typeName = getDefinedTypeName(type) ?? type.name;
+            return {
+                ...transformCommonTypeFields(type, typeName, context),
+                type: typeName,
+                ...typeName === type.name ? {} : {
+                    name: type.name
+                },
+                ...ensureCustomTitle(type.name, type.title)
+            };
+        })
+    };
+}
+function transformReference(reference) {
+    return {
+        to: (reference.to ?? []).map((type)=>{
+            return {
+                ...retainCustomTypeProps(type),
+                type: type.name
+            };
+        })
+    };
+}
+function transformCrossDatasetReference(reference) {
+    return {
+        to: (reference.to ?? []).map((crossDataset)=>{
+            const preview = crossDataset.preview?.select ? {
+                preview: {
+                    select: crossDataset.preview.select
+                }
+            } : {};
+            return {
+                type: crossDataset.type,
+                ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+                ...preview
+            };
+        })
+    };
+}
+function transformGlobalDocumentReference(reference) {
+    return {
+        to: (reference.to ?? []).map((crossDataset)=>{
+            const preview = crossDataset.preview?.select ? {
+                preview: {
+                    select: crossDataset.preview.select
+                }
+            } : {};
+            return {
+                type: crossDataset.type,
+                ...ensureCustomTitle(crossDataset.type, crossDataset.title),
+                ...preview
+            };
+        })
+    };
+}
+const transformTypeValidationRule = (rule)=>{
+    return {
+        ...rule,
+        constraint: 'constraint' in rule && (typeof rule.constraint === 'string' ? rule.constraint.toLowerCase() : retainSerializableProps(rule.constraint))
+    };
+};
+const validationRuleTransformers = {
+    type: transformTypeValidationRule
+};
+function transformValidation(validation) {
+    const validationArray = (Array.isArray(validation) ? validation : [
+        validation
+    ]).filter((value)=>typeof value === 'object' && '_type' in value);
+    // we dont want type in the output as that is implicitly given by the typedef itself an will only bloat the payload
+    const disallowedFlags = new Set([
+        'type'
+    ]);
+    // Validation rules that refer to other fields use symbols, which cannot be serialized. It would
+    // be possible to transform these to a serializable type, but we haven't implemented that for now.
+    const disallowedConstraintTypes = new Set([
+        ConcreteRuleClass.FIELD_REF
+    ]);
+    const serializedValidation = validationArray.map(({ _level, _message, _rules })=>{
+        const message = typeof _message === 'string' ? {
+            message: _message
+        } : {};
+        const serializedRules = _rules.filter((rule)=>{
+            if (!('constraint' in rule)) {
+                return false;
+            }
+            const { constraint, flag } = rule;
+            if (disallowedFlags.has(flag)) {
+                return false;
+            }
+            return !(typeof constraint === 'object' && 'type' in constraint && disallowedConstraintTypes.has(constraint.type));
+        }).map((rule)=>{
+            const transformer = validationRuleTransformers[rule.flag] ?? ((spec)=>retainSerializableProps(spec));
+            const transformedRule = transformer(rule);
+            if (!transformedRule) {
+                return;
+            }
+            return transformedRule;
+        }).filter((rule)=>rule !== undefined);
+        return {
+            level: _level,
+            rules: serializedRules,
+            ...message
+        };
+    }).filter((group)=>group.rules.length > 0);
+    return serializedValidation.length > 0 ? {
+        validation: serializedValidation
+    } : {};
+}
+function ensureCustomTitle(typeName, value) {
+    const titleObject = ensureString('title', value);
+    const defaultTitle = startCase(typeName);
+    // omit title if its the same as default, to reduce payload
+    if (titleObject.title === defaultTitle) {
+        return {};
+    }
+    return titleObject;
+}
+function ensureString(key, value) {
+    if (typeof value === 'string') {
+        return {
+            [key]: value
+        };
+    }
+    return {};
+}
+function ensureConditional(key, value) {
+    if (typeof value === 'boolean') {
+        return {
+            [key]: value
+        };
+    }
+    if (typeof value === 'function') {
+        return {
+            [key]: 'conditional'
+        };
+    }
+    return {};
+}
+function transformBlockType(blockType, context) {
+    if (blockType.jsonType !== 'object' || !isType(blockType, 'block')) {
+        return {};
+    }
+    const childrenField = blockType.fields?.find((field)=>field.name === 'children');
+    if (!childrenField) {
+        return {};
+    }
+    const ofType = childrenField.type.of;
+    if (!ofType) {
+        return {};
+    }
+    const spanType = ofType.find((memberType)=>memberType.name === 'span');
+    if (!spanType) {
+        return {};
+    }
+    const inlineObjectTypes = ofType.filter((memberType)=>memberType.name !== 'span') || [];
+    return {
+        lists: resolveEnabledListItems(blockType),
+        marks: {
+            annotations: spanType.annotations.map((t)=>transformType(t, context)),
+            decorators: resolveEnabledDecorators(spanType)
+        },
+        of: inlineObjectTypes.map((t)=>transformType(t, context)),
+        styles: resolveEnabledStyles(blockType)
+    };
+}
+function resolveEnabledStyles(blockType) {
+    const styleField = blockType.fields?.find((btField)=>btField.name === 'style');
+    return resolveTitleValueArray(styleField?.type?.options?.list);
+}
+function resolveEnabledDecorators(spanType) {
+    return 'decorators' in spanType ? resolveTitleValueArray(spanType.decorators) : undefined;
+}
+function resolveEnabledListItems(blockType) {
+    const listField = blockType.fields?.find((btField)=>btField.name === 'listItem');
+    return resolveTitleValueArray(listField?.type?.options?.list);
+}
+function resolveTitleValueArray(possibleArray) {
+    if (!possibleArray || !Array.isArray(possibleArray)) {
+        return undefined;
+    }
+    const titledValues = possibleArray.filter((d)=>isRecord(d) && !!d.value && isString(d.value)).map((item)=>{
+        return {
+            value: item.value,
+            ...ensureString('title', item.title)
+        };
+    });
+    if (!titledValues?.length) {
+        return undefined;
+    }
+    return titledValues;
+}
+const extractManifestTools = (tools)=>tools.map((tool)=>{
+        const { __internalApplicationType: type, icon, name, title } = tool;
+        return {
+            icon: resolveIcon({
+                icon: icon,
+                title
+            }),
+            name,
+            title,
+            type: type || null
+        };
+    });
+const resolveIcon = (props)=>{
+    const sheet = new ServerStyleSheet();
+    try {
+        /**
+     * You must render the element first so
+     * the style-sheet above can be populated
+     */ const element = renderToString(sheet.collectStyles(/*#__PURE__*/ _jsx(SchemaIcon, {
+            ...props
+        })));
+        const styleTags = sheet.getStyleTags();
+        /**
+     * We can then create a single string
+     * of HTML combining our styles and element
+     * before purifying below.
+     */ const html = `${styleTags}${element}`.trim();
+        return DOMPurify.sanitize(html, config);
+    } catch  {
+        return null;
+    } finally{
+        sheet.seal();
+    }
+};
+
+//# sourceMappingURL=extractWorkspaceManifest.js.map