@sanity/assist 6.1.21 → 6.2.0

package/README.md

@@ -180,6 +180,7 @@ assist({
   assist: {
     localeSettings: () => Intl.DateTimeFormat().resolvedOptions(),
     maxPathDepth: 4,
+    maxFieldSelectionDepth: 6,
     temperature: 0.3,
   },
   translate: {/* see sections about document and field translation */},
@@ -188,6 +189,7 @@ assist({
 
 - `localeSettings`: See section on [date and datetime](#date-and-datetime)
 - `maxPathDepth`: The max depth for document paths AI Assist will write to.
+- `maxFieldSelectionDepth`: The max depth for fields that can be selected for AI Assist. Fields nested deeper than this get no AI Assist field action, are not listed in the field picker when editing instructions, and cannot be referenced from an instruction. Depth is counted in path segments from the document root (`title` has depth 1, `array[_key="no"].title` has depth 3). Be careful not to set this too high in studios with recursive document schemas, as it could have negative impact on performance.
 - `temperature`: Influences how much the output of an instruction will vary between runs.
 
 For more details, please review the TSDocs of the individual config parameters in [assistTypes.ts](./src/assistTypes.ts).
@@ -658,6 +660,8 @@ assist({
 Be careful not to set this too high in studios with recursive document schemas, as it could have negative impact on performance.
 maxPathDepth is hard-capped to 50.
 
+`translate.field.maxPathDepth` only affects the "Translate fields" action. Which fields get an AI Assist field action at all is controlled by `assist.maxFieldSelectionDepth` (see [Assist configuration](#assist-configuration-optional)).
+
 ### Loading field languages
 
 Languages must be an array of objects with an id and title.

package/dist/index.d.ts

@@ -37,6 +37,23 @@ interface AssistConfig {
    * Default: 4
    */
   maxPathDepth?: number;
+  /**
+   * The max depth for fields that can be selected for AI Assist in the Studio: fields deeper than this
+   * get no AI Assist field action (the sparkle button), are not listed in the field picker when editing
+   * instructions, and cannot be referenced from an instruction prompt.
+   *
+   * Depth is based on field path segments, counted from the document root:
+   * - `title` has depth 1
+   * - `array[_key="no"].title` has depth 3
+   *
+   * Unlike `maxPathDepth`, this does not affect what an instruction can write to once it runs.
+   *
+   * Be careful not to set this too high in studios with recursive document schemas, as it could have
+   * negative impact on performance.
+   *
+   * Default: 6
+   */
+  maxFieldSelectionDepth?: number;
   /**
    * Influences how much the output of an instruction will vary.
    *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/assistTypes.ts","../src/fieldActions/customFieldActions.tsx","../src/translate/types.ts","../src/types.ts","../src/plugin.tsx","../src/schemas/serialize/SchemTypeTool.tsx","../src/schemas/typeDefExtensions.ts","../src/translate/paths.ts","../src/fieldActions/useUserInput.ts","../src/helpers/typeUtils.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/assistTypes.ts","../src/fieldActions/customFieldActions.tsx","../src/translate/types.ts","../src/types.ts","../src/plugin.tsx","../src/schemas/serialize/SchemTypeTool.tsx","../src/schemas/typeDefExtensions.ts","../src/translate/paths.ts","../src/fieldActions/useUserInput.ts","../src/helpers/typeUtils.ts"],"mappings":"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"}

package/dist/index.js

@@ -36,7 +36,7 @@ import { ErrorOutlineIcon } from "@sanity/icons/ErrorOutline";
 import { SyncIcon } from "@sanity/icons/Sync";
 import { Popover } from "@sanity/ui/popover";
 import { formatDistanceToNow } from "date-fns/formatDistanceToNow";
-import isEqual from "react-fast-compare";
+import { dequal } from "dequal/lite";
 import get from "lodash-es/get.js";
 import { Icon, icons } from "@sanity/icons";
 import { ControlsIcon } from "@sanity/icons/Controls";
@@ -291,7 +291,7 @@ function mapConnectorToLine(options, connector) {
 		to
 	};
 }
-const assistDocumentIdPrefix = "sanity.assist.schemaType.", assistDocumentStatusIdPrefix = "sanity.assist.status.", assistDocumentTypeName = "sanity.assist.schemaType.annotations", assistFieldTypeName = "sanity.assist.schemaType.field", userInputTypeName = "sanity.assist.instruction.userInput", contextDocumentTypeName = "assist.instruction.context", assistTasksStatusTypeName = "sanity.assist.task.status", instructionTaskTypeName = "sanity.assist.instructionTask", fieldPresenceTypeName = "sanity.assist.instructionTask.presence", assistSerializedTypeName = "sanity.assist.serialized.type", assistSerializedFieldTypeName = "sanity.assist.serialized.field", fieldPathParam = "pathKey", instructionParam = "instruction", documentRootKey = "<document>";
+const assistDocumentStatusIdPrefix = "sanity.assist.status.", assistDocumentTypeName = "sanity.assist.schemaType.annotations", assistFieldTypeName = "sanity.assist.schemaType.field", userInputTypeName = "sanity.assist.instruction.userInput", fieldReferenceTypeName = "sanity.assist.instruction.fieldRef", contextDocumentTypeName = "assist.instruction.context", assistTasksStatusTypeName = "sanity.assist.task.status", instructionTaskTypeName = "sanity.assist.instructionTask", fieldPresenceTypeName = "sanity.assist.instructionTask.presence", assistSerializedTypeName = "sanity.assist.serialized.type", assistSerializedFieldTypeName = "sanity.assist.serialized.field", fieldPathParam = "pathKey", instructionParam = "instruction", documentRootKey = "<document>";
 function usePathKey(path) {
 	let $ = c(2), t0;
 	return $[0] === path ? t0 = $[1] : (t0 = getPathKey(path), $[0] = path, $[1] = t0), t0;
@@ -364,7 +364,7 @@ function _temp$16(member) {
 }
 const releaseAnnouncementUrl = "https://www.sanity.io/blog/sanity-ai-assist-announcement?utm_source=sanity-assist-plugin&utm_medium=organic_social&utm_campaign=ai-assist&utm_content=", packageName = "@sanity/assist", pluginTitle = "Sanity AI Assist", pluginTitleShort = "AI Assist", maxHistoryVisibilityMs = minutesToMilliseconds(30), illegalIdChars = /[^a-zA-Z0-9._-]/g;
 function assistDocumentId(documentType) {
-	return `${assistDocumentIdPrefix}${documentType}`.replace(illegalIdChars, "_");
+	return `sanity.assist.schemaType.${documentType}`.replace(illegalIdChars, "_");
 }
 function assistTasksStatusId(documentId) {
 	return isVersionId(documentId) ? `${assistDocumentStatusIdPrefix}${getVersionFromId(documentId)}.${getPublishedId(documentId)}` : `${assistDocumentStatusIdPrefix}${getPublishedId(documentId)}`;
@@ -588,15 +588,25 @@ function getDocumentFieldRef(schemaType) {
 		schemaType
 	};
 }
-function getFieldRefs(schemaType, parent, depth = 0) {
-	return depth >= 6 ? [] : schemaType.fields.filter((f) => !f.name.startsWith("_")).flatMap((field) => {
+/**
+* Collects every field (and synthetic array item) in `schemaType` that AI Assist can attach
+* instructions to.
+*
+* @param maxDepth - max number of path segments a collected field can have; deeper fields are
+* skipped. Arrays contribute one segment for the item type (`array[_key="type"]`).
+*/
+function getFieldRefs(schemaType, maxDepth = 6) {
+	return getObjectFieldRefs(schemaType, void 0, 0, maxDepth);
+}
+function getObjectFieldRefs(schemaType, parent, depth, maxDepth) {
+	return depth >= maxDepth ? [] : schemaType.fields.filter((f) => !f.name.startsWith("_")).flatMap((field) => {
 		let path = parent ? [...parent.path, field.name] : [field.name], title = field.type.title ?? field.name, fieldRef = {
 			key: patchableKey(pathToString(path)),
 			path,
 			title: parent ? [parent.title, title].join(" / ") : title,
 			schemaType: field.type,
 			icon: getTypeIcon(field.type)
-		}, fields = field.type.jsonType === "object" ? getFieldRefs(field.type, fieldRef, depth + 1) : [], syntheticFields = field.type.jsonType === "array" ? getSyntheticFields(field.type, fieldRef, depth + 1) : [];
+		}, fields = field.type.jsonType === "object" ? getObjectFieldRefs(field.type, fieldRef, depth + 1, maxDepth) : [], syntheticFields = field.type.jsonType === "array" ? getSyntheticFields(field.type, fieldRef, depth + 1, maxDepth) : [];
 		return isAssistSupported(field.type) ? [
 			fieldRef,
 			...fields,
@@ -604,8 +614,8 @@ function getFieldRefs(schemaType, parent, depth = 0) {
 		] : [...fields, ...syntheticFields];
 	});
 }
-function getSyntheticFields(schemaType, parent, depth = 0) {
-	return depth >= 6 ? [] : schemaType.of.filter((itemType) => !isType(itemType, "block")).flatMap((itemType) => {
+function getSyntheticFields(schemaType, parent, depth, maxDepth) {
+	return depth >= maxDepth ? [] : schemaType.of.filter((itemType) => !isType(itemType, "block")).flatMap((itemType) => {
 		let segment = { _key: itemType.name }, title = itemType.title ?? itemType.name, path = parent ? [...parent.path, segment] : [segment], fieldRef = {
 			key: patchableKey(pathToString(path)),
 			path,
@@ -613,7 +623,7 @@ function getSyntheticFields(schemaType, parent, depth = 0) {
 			schemaType: itemType,
 			icon: getTypeIcon(itemType),
 			synthetic: !0
-		}, fields = itemType.jsonType === "object" ? getFieldRefs(itemType, fieldRef, depth + 1) : [];
+		}, fields = itemType.jsonType === "object" ? getObjectFieldRefs(itemType, fieldRef, depth + 1, maxDepth) : [];
 		return isAssistSupported(itemType) ? [fieldRef, ...fields] : fields;
 	});
 }
@@ -2163,7 +2173,7 @@ function TaskItem(props) {
 */
 function isolatePathParams(nextParams, hostParams) {
 	let { path: nextLocalPath, ...restNext } = nextParams, { path: hostPath, ...restHost } = hostParams;
-	return isEqual(restNext, restHost) ? {
+	return dequal(restNext, restHost) ? {
 		nextLocalPath,
 		forwardParams: null
 	} : {
@@ -3177,12 +3187,16 @@ function refToTypeNames(type) {
 function removeUndef(obj) {
 	return Object.keys(obj).forEach((key) => obj[key] === void 0 ? delete obj[key] : {}), obj;
 }
-function createFieldRefCache() {
+/**
+* @param maxFieldSelectionDepth - see `AssistConfig.maxFieldSelectionDepth`; uses the plugin
+* default when omitted
+*/
+function createFieldRefCache(maxFieldSelectionDepth) {
 	let byType = {};
 	function getRefsForType(schemaType) {
 		let documentType = schemaType.name, cached = byType[documentType];
 		if (cached) return cached;
-		let fieldRefs = getFieldRefs(schemaType), refs = {
+		let fieldRefs = getFieldRefs(schemaType, maxFieldSelectionDepth), refs = {
 			fieldRefs,
 			fieldRefsByTypePath: asFieldRefsByTypePath(fieldRefs)
 		};
@@ -3193,7 +3207,7 @@ function createFieldRefCache() {
 function AiAssistanceConfigProvider(props) {
 	let $ = c(21), [status, setStatus] = useState(), [error, setError] = useState(), apiClient = useApiClient(props.config?.__customApiClient), { getInstructStatus, loading: statusLoading } = useGetInstructStatus(apiClient), { initInstruct, loading: initLoading } = useInitInstruct(apiClient), schema = useSchema(), t0;
 	$[0] === schema ? t0 = $[1] : (t0 = serializeSchema(schema, { leanFormat: !0 }), $[0] = schema, $[1] = t0);
-	let serializedTypes = t0, { getFieldRefs, getFieldRefsByTypePath } = useFieldRefGetters(schema), t1, t2;
+	let serializedTypes = t0, { getFieldRefs, getFieldRefsByTypePath } = useFieldRefGetters(schema, props.config.assist?.maxFieldSelectionDepth), t1, t2;
 	$[2] === getInstructStatus ? (t1 = $[3], t2 = $[4]) : (t1 = () => {
 		getInstructStatus().then((s) => setStatus(s)).catch((e) => {
 			console.error(e), setError(e);
@@ -3229,20 +3243,20 @@ function AiAssistanceConfigProvider(props) {
 		children
 	}), $[18] = children, $[19] = context, $[20] = t5) : t5 = $[20], t5;
 }
-function useFieldRefGetters(schema) {
-	let $ = c(5), t0;
-	$[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = createFieldRefCache(), $[0] = t0) : t0 = $[0];
+function useFieldRefGetters(schema, maxFieldSelectionDepth) {
+	let $ = c(7), t0;
+	$[0] === maxFieldSelectionDepth ? t0 = $[1] : (t0 = createFieldRefCache(maxFieldSelectionDepth), $[0] = maxFieldSelectionDepth, $[1] = t0);
 	let getForSchemaType = t0, t1;
-	$[1] === schema ? t1 = $[2] : (t1 = function getRefsForType(documentType) {
+	$[2] !== getForSchemaType || $[3] !== schema ? (t1 = function getRefsForType(documentType) {
 		let schemaType = schema.get(documentType);
 		if (!schemaType) throw Error(`Schema type "${documentType}" not found`);
 		return getForSchemaType(schemaType);
-	}, $[1] = schema, $[2] = t1);
+	}, $[2] = getForSchemaType, $[3] = schema, $[4] = t1) : t1 = $[4];
 	let getRefsForType = t1, t2;
-	return $[3] === getRefsForType ? t2 = $[4] : (t2 = {
+	return $[5] === getRefsForType ? t2 = $[6] : (t2 = {
 		getFieldRefs: (documentType_0) => getRefsForType(documentType_0).fieldRefs,
 		getFieldRefsByTypePath: (documentType_1) => getRefsForType(documentType_1).fieldRefsByTypePath
-	}, $[3] = getRefsForType, $[4] = t2), t2;
+	}, $[5] = getRefsForType, $[6] = t2), t2;
 }
 function AssistLayout(props) {
 	let $ = c(11), t0;
@@ -4697,46 +4711,55 @@ const contextDocumentSchema = defineType({
 			};
 		}
 	}
-}), fieldReference = defineType({
-	type: "object",
-	name: "sanity.assist.instruction.fieldRef",
-	title: "Field",
-	icon: ThListIcon,
-	fields: [defineField({
-		type: "string",
-		name: "path",
+});
+/**
+* The validation rule resolves the selected path against the same field-ref tree the field picker
+* offers, so it has to be built with the same `assist.maxFieldSelectionDepth`.
+*/
+function createFieldReferenceType(maxFieldSelectionDepth) {
+	return defineType({
+		type: "object",
+		name: fieldReferenceTypeName,
 		title: "Field",
-		components: { input: FieldRefPathInput },
-		validation: (rule) => {
-			let getForSchemaType = createFieldRefCache();
-			return rule.custom((value, context) => {
-				if (!value) return "Please select a field";
-				try {
-					let docId = context.document?._id;
-					if (!docId) return "Field reference cannot be used outside document inspector context. Could not resolve document id.";
-					let targetDocType = docId.replace(RegExp(`^${assistDocumentIdPrefix}`), ""), schema = context.schema.get(targetDocType);
-					if (!schema) return `Field reference cannot be used outside document inspector context. Could not resolve schema: ${targetDocType}`;
-					let { fieldRefs } = getForSchemaType(schema);
-					return fieldRefs.find((r) => r.key === value) ? !0 : `Field with path "${value}" does not exist in the schema.`;
-				} catch (e) {
-					return console.error("Failed to resolve field reference", e), "Invalid field reference.";
-				}
-			});
-		}
-	})],
-	preview: {
-		select: { path: "path" },
-		prepare({ path }) {
-			return {
-				title: path,
-				path,
-				icon: CodeIcon
-			};
-		}
-	},
-	components: { preview: FieldRefPreview },
-	options: { modal: { type: "popover" } }
-}), userInput = defineType({
+		icon: ThListIcon,
+		fields: [defineField({
+			type: "string",
+			name: "path",
+			title: "Field",
+			components: { input: FieldRefPathInput },
+			validation: (rule) => {
+				let getForSchemaType = createFieldRefCache(maxFieldSelectionDepth);
+				return rule.custom((value, context) => {
+					if (!value) return "Please select a field";
+					try {
+						let docId = context.document?._id;
+						if (!docId) return "Field reference cannot be used outside document inspector context. Could not resolve document id.";
+						if (!docId.startsWith("sanity.assist.schemaType.")) return `Field reference cannot be used outside document inspector context. Could not resolve document id: ${docId}`;
+						let targetDocType = docId.slice(25), schema = context.schema.get(targetDocType);
+						if (!schema) return `Field reference cannot be used outside document inspector context. Could not resolve schema: ${targetDocType}`;
+						let { fieldRefs } = getForSchemaType(schema);
+						return fieldRefs.find((r) => r.key === value) ? !0 : `Field with path "${value}" does not exist in the schema.`;
+					} catch (e) {
+						return console.error("Failed to resolve field reference", e), "Invalid field reference.";
+					}
+				});
+			}
+		})],
+		preview: {
+			select: { path: "path" },
+			prepare({ path }) {
+				return {
+					title: path,
+					path,
+					icon: CodeIcon
+				};
+			}
+		},
+		components: { preview: FieldRefPreview },
+		options: { modal: { type: "popover" } }
+	});
+}
+const userInput = defineType({
 	type: "object",
 	name: userInputTypeName,
 	title: "User input",
@@ -4812,7 +4835,7 @@ const contextDocumentSchema = defineType({
 			annotations: []
 		},
 		of: [
-			defineArrayMember({ type: fieldReference.name }),
+			defineArrayMember({ type: fieldReferenceTypeName }),
 			defineArrayMember({ type: promptContext.name }),
 			defineArrayMember({ type: userInput.name })
 		]
@@ -5062,29 +5085,37 @@ function excludeComments(type) {
 		..."of" in type ? { of: type.of?.map((arrayItemType) => excludeComments(arrayItemType)) } : {}
 	};
 }
-const schemaTypes = [
-	...[
-		fieldInstructions,
-		instruction,
-		fieldReference,
-		prompt,
-		userInput,
-		promptContext
-	].map(excludeComments),
-	outputFieldType,
-	outputTypeType,
-	assistDocumentSchema,
-	documentInstructionStatus,
-	instructionTask,
-	contextDocumentSchema
-], assist = definePlugin((config) => {
-	let configWithDefaults = config ?? {}, styleguide = configWithDefaults.translate?.styleguide || "", maxPathDepth = configWithDefaults.assist?.maxPathDepth, temperature = configWithDefaults.assist?.temperature;
+/**
+* @param maxFieldSelectionDepth - see `AssistConfig.maxFieldSelectionDepth`; the field reference
+* type validates picked paths against the field-ref tree, which must be built with the same depth
+*/
+function createSchemaTypes(maxFieldSelectionDepth) {
+	return [
+		...[
+			fieldInstructions,
+			instruction,
+			createFieldReferenceType(maxFieldSelectionDepth),
+			prompt,
+			userInput,
+			promptContext
+		].map(excludeComments),
+		outputFieldType,
+		outputTypeType,
+		assistDocumentSchema,
+		documentInstructionStatus,
+		instructionTask,
+		contextDocumentSchema
+	];
+}
+const assist = definePlugin((config) => {
+	let configWithDefaults = config ?? {}, styleguide = configWithDefaults.translate?.styleguide || "", maxPathDepth = configWithDefaults.assist?.maxPathDepth, maxFieldSelectionDepth = configWithDefaults.assist?.maxFieldSelectionDepth, temperature = configWithDefaults.assist?.temperature;
 	if (typeof styleguide == "string" && validateStyleguide(styleguide), maxPathDepth !== void 0 && (maxPathDepth < 1 || maxPathDepth > 12)) throw Error(`[${packageName}]: \`assist.maxPathDepth\` must be be in the range [1,12] inclusive, but was ${maxPathDepth}`);
+	if (maxFieldSelectionDepth !== void 0 && (!Number.isInteger(maxFieldSelectionDepth) || maxFieldSelectionDepth < 1 || maxFieldSelectionDepth > 12)) throw Error(`[${packageName}]: \`assist.maxFieldSelectionDepth\` must be an integer in the range [1,12] inclusive, but was ${maxFieldSelectionDepth}`);
 	if (temperature !== void 0 && (temperature < 0 || temperature > 1)) throw Error(`[${packageName}]: \`assist.temperature\` must be in the range [0,1] inclusive, but was ${temperature}`);
 	return {
 		name: packageName,
 		handlesGDR: !0,
-		schema: { types: schemaTypes },
+		schema: { types: createSchemaTypes(maxFieldSelectionDepth) },
 		i18n: { bundles: [{}] },
 		document: {
 			inspectors: (prev, context) => {
@@ -5152,8 +5183,8 @@ function useListeningQuery(query, t0, t1) {
 	let $ = c(11), params = t0 === void 0 ? DEFAULT_PARAMS : t0, options = t1 === void 0 ? DEFAULT_OPTIONS : t1, [loading, setLoading] = useState(!0), [error, setError] = useState(!1), [data, setData] = useState(null), subscription = useRef(null), t2;
 	$[0] === Symbol.for("react.memo_cache_sentinel") ? (t2 = { apiVersion: "v2022-05-09" }, $[0] = t2) : t2 = $[0];
 	let client = useClient(t2), t3, t4;
-	$[1] !== client || $[2] !== options || $[3] !== params || $[4] !== query ? (t3 = () => (query && (subscription.current = listenQuery(client, query, params, options).pipe(distinctUntilChanged(isEqual), catchError((err) => (console.error(err), setError(!0), setLoading(!1), setData(null), of(null)))).subscribe((documents) => {
-		setData((current) => isEqual(current, documents) ? current : documents), setLoading(!1), setError(!1);
+	$[1] !== client || $[2] !== options || $[3] !== params || $[4] !== query ? (t3 = () => (query && (subscription.current = listenQuery(client, query, params, options).pipe(distinctUntilChanged(dequal), catchError((err) => (console.error(err), setError(!0), setLoading(!1), setData(null), of(null)))).subscribe((documents) => {
+		setData((current) => dequal(current, documents) ? current : documents), setLoading(!1), setError(!1);
 	})), () => subscription.current ? subscription.current.unsubscribe() : void 0), t4 = [
 		query,
 		params,