@persona/design-system 0.7.2 → 0.8.0

package/dist/lib/schemaOptions.d.mts

@@ -0,0 +1,173 @@
+import { T as JsonSchemaTypes, b as JsonSchemaObjectKey, c as JsonSchemaBasicTypes, dt as ObjectSchemaMap, f as JsonSchemaCustomTypes, n as JsonSchema, st as FunctionJsonSchema, y as JsonSchemaObject } from "../jsonSchema-CfGi1bzI.mjs";
+import { n as Chain, s as MethodChainNode } from "../methodChainTypes-CqWzfx0M.mjs";
+
+//#region lib/schemaOptions.d.ts
+type VariableSchemaObject = {
+  value: string;
+  schema?: JsonSchema | null;
+  isVariable?: boolean;
+};
+type Option = {
+  label: string;
+  value: string;
+  property: string;
+  schema: JsonSchema | FunctionJsonSchema;
+  methodChain: Chain | null;
+  utility?: boolean;
+  workflowObjectKey?: string;
+  isVariable?: boolean;
+};
+/**
+ * Extracts the top-level platform-object key from a schema's `$ref`/`$id`/
+ * `objectKey`/`objectType.const` markers. Collapses subtypes to their root
+ * (`/schema/verification/document/merged` -> `verification`) because callers
+ * compare against top-level `ApiModel` values.
+ */
+declare const extractPlatformObjectKey: (schema: JsonSchema | null | undefined, platformObjectJsonSchema?: ObjectSchemaMap) => string | null;
+type PossibleType = JsonSchemaTypes | JsonSchemaCustomTypes | JsonSchemaObjectKey;
+type PossibleArrayType = JsonSchemaBasicTypes | JsonSchemaTypes.Object | JsonSchemaObjectKey;
+declare const isValidOption: (schema: JsonSchema, allowedFieldPaths: string[], disallowedFieldPaths: string[], allowedTypes: PossibleType[], allowedArrayTypes: PossibleArrayType[], path: string[] | undefined, platformObjectJsonSchema: ObjectSchemaMap) => boolean;
+declare const getSchemaOptions: ({
+  option,
+  optionFilters,
+  platformObjectJsonSchema,
+  primitiveUtilities,
+  digPrimitives
+}: {
+  option: Pick<Option, "schema" | "methodChain">;
+  optionFilters?: OptionFilters;
+  platformObjectJsonSchema: ObjectSchemaMap;
+  primitiveUtilities: ObjectSchemaMap;
+  digPrimitives?: boolean;
+}) => Option[];
+declare const formatDisplayValue: (value: any) => string;
+/**
+ * Resolves the schema at a dotted path (e.g. "account.birthDate").
+ * Tries direct key lookup first, then traverses into nested object .properties by path part.
+ * Normalizes kebab/snake at each level for key lookup.
+ */
+declare function getSchemaByPath(properties: Record<string, JsonSchema> | null | undefined, path: string): JsonSchema | undefined;
+declare const getSchemaForFieldPath: ({
+  path,
+  initialSchema,
+  platformObjectJsonSchema,
+  primitiveUtilities
+}: {
+  path: string;
+  initialSchema: JsonSchema;
+  platformObjectJsonSchema?: ObjectSchemaMap;
+  primitiveUtilities?: ObjectSchemaMap;
+}) => {
+  schema: JsonSchema | null;
+  propertyName: string | null;
+};
+/**
+ * Get the schema for a variable path from usableObjects.
+ */
+declare const getSchemaForVariablePath: ({
+  path,
+  usableObjects
+}: {
+  path: string;
+  usableObjects: VariableSchemaObject[];
+}) => {
+  schema: JsonSchema | null;
+  propertyName: string | null;
+};
+declare const nextLinkSchema: ({
+  currentSchema,
+  nextLink,
+  platformObjectJsonSchema,
+  primitiveUtilities
+}: {
+  currentSchema: JsonSchema | null;
+  nextLink: MethodChainNode;
+  platformObjectJsonSchema: ObjectSchemaMap;
+  primitiveUtilities: ObjectSchemaMap;
+}) => JsonSchema | null;
+/**
+ * Returns the FunctionJsonSchema for `functionName` within `parentSchema`, checking both
+ * primitive utilities (e.g. array/string methods) and direct object properties.
+ * Returns null if not found or not a function schema.
+ */
+declare const getFunctionSchemaForNode: ({
+  parentSchema,
+  functionName,
+  isCustomFunction,
+  platformObjectJsonSchema,
+  primitiveUtilities
+}: {
+  parentSchema: JsonSchema;
+  functionName: string;
+  isCustomFunction: boolean;
+  platformObjectJsonSchema: ObjectSchemaMap;
+  primitiveUtilities: ObjectSchemaMap;
+}) => FunctionJsonSchema | null;
+declare const isTypeMatch: ({
+  fieldJsonSchema,
+  types,
+  platformObjectJsonSchema,
+  arrayTypes,
+  traversedSchemaIds
+}: {
+  fieldJsonSchema: JsonSchema;
+  types: PossibleType[];
+  platformObjectJsonSchema: ObjectSchemaMap;
+  arrayTypes?: PossibleArrayType[];
+  traversedSchemaIds?: Set<string>;
+}) => boolean;
+interface OptionFilters {
+  allowedArrayTypes?: PossibleArrayType[];
+  allowedFieldPaths?: string[];
+  allowedTypes?: PossibleType[];
+  disallowedFieldPaths?: string[];
+  fieldPathsAreStrictMatch?: boolean;
+  requiredPropertyShape?: string[];
+}
+declare const hasRequiredPropertyShape: (schema: JsonSchema, requiredPropertyShape: string[], platformObjectJsonSchema?: ObjectSchemaMap, checkRecursively?: boolean) => boolean;
+declare const getOptionForValue: ({
+  value,
+  jsonSchema,
+  schemaForFieldPath
+}: {
+  value: string;
+  jsonSchema: JsonSchema;
+  schemaForFieldPath: (path: string, initialSchema: JsonSchema) => {
+    schema: JsonSchema | null;
+    propertyName: string | null;
+  };
+}) => Option | null;
+declare const validatePath: ({
+  path,
+  jsonSchema,
+  platformObjectJsonSchema,
+  primitiveUtilities,
+  optionFilters
+}: {
+  path: string;
+  jsonSchema: JsonSchema;
+  platformObjectJsonSchema: ObjectSchemaMap;
+  primitiveUtilities: ObjectSchemaMap;
+  optionFilters?: OptionFilters;
+}) => {
+  valid: boolean;
+  schemaOptions: Option[];
+  partial: string;
+};
+/**
+ * Given a method chain that corresponds to the passed schema, find the right-most indentifier that
+ * is a platform object and split the method chain on that identifier, with the platform object on
+ * the left side.
+ *
+ * This function is used to optimize a method chain into two parts, left side for server resolution
+ * and right side for client resolution.
+ *
+ * For example:
+ * current_case.fields.field_a -> ['current_case', 'fields.field_a']
+ * current_case.inquiries.first.id -> ['current_case.inquiries.first', 'id']
+ * current_case.account.fields.field_b -> ['current_case.account', 'fields.field_b']
+ */
+declare const splitAtNearestParentObject: (chain: Chain, currentSchema: JsonSchemaObject, platformSchemaMap: ObjectSchemaMap, primitiveUtilities: ObjectSchemaMap) => [leftChain: Chain, rightChain: Chain];
+//#endregion
+export { Option, OptionFilters, extractPlatformObjectKey, formatDisplayValue, getFunctionSchemaForNode, getOptionForValue, getSchemaByPath, getSchemaForFieldPath, getSchemaForVariablePath, getSchemaOptions, hasRequiredPropertyShape, isTypeMatch, isValidOption, nextLinkSchema, splitAtNearestParentObject, validatePath };
+//# sourceMappingURL=schemaOptions.d.mts.map

package/dist/lib/schemaOptions.mjs

@@ -0,0 +1,481 @@
+import { EMPTY_JSON_SCHEMA_OBJECT, JsonSchemaAllTypes, JsonSchemaStringifiableTypes, genericArrayItemSchema, getNonNullableRefSchema, getNonNullableType, isConvertedTypeSchema, isFileType, isFunctionSchema, isGenericParameterSchema, isJsonSchemaArray, isJsonSchemaDate, isJsonSchemaDateTime, isJsonSchemaObject, isJsonSchemaRef, isJsonSchemaString, isJsonType, isPrecedingSchema } from "./jsonSchema.mjs";
+import { getJsonSchemaType } from "./jsonSchemaType.mjs";
+import { _ as methodChainToString, d as isIdentifierNode, f as isStringNode, n as MethodChainNodeTypes, p as isValid, r as appendedMethodChain, t as EMPTY_METHOD_CHAIN, u as isFunctionNode, v as parseMethodChain, w as assertNever, y as parseWithPartialOption } from "../methodChain-DAQxLgxt.mjs";
+import { MERGED_SCHEMA_ID, getPlatformObjectTypeFromJsonSchema, getSchemaId, resolveJssRef } from "./platformObject.mjs";
+import { compact, flatten, last, sortBy, trim } from "lodash-es";
+//#region lib/schemaOptions.ts
+const fullNodeName = (node) => `${node.type === MethodChainNodeTypes.CustomFunction ? "@" : ""}${node.name}`;
+const SCHEMA_PATH_PATTERN = /\/schema\/([a-z][a-z0-9-_]*)/i;
+/**
+* Extracts the top-level platform-object key from a schema's `$ref`/`$id`/
+* `objectKey`/`objectType.const` markers. Collapses subtypes to their root
+* (`/schema/verification/document/merged` -> `verification`) because callers
+* compare against top-level `ApiModel` values.
+*/
+const extractPlatformObjectKey = (schema, platformObjectJsonSchema = {}) => {
+	if (!schema) return null;
+	if (isJsonSchemaRef(schema)) {
+		const refMatch = schema.$ref?.match(SCHEMA_PATH_PATTERN);
+		if (refMatch) return refMatch[1];
+		return extractPlatformObjectKey(resolveJssRef(schema, platformObjectJsonSchema), platformObjectJsonSchema);
+	}
+	if ("$id" in schema && typeof schema.$id === "string") {
+		const idMatch = schema.$id.match(SCHEMA_PATH_PATTERN);
+		if (idMatch) return idMatch[1];
+	}
+	if ("objectKey" in schema && typeof schema.objectKey === "string") return schema.objectKey.split("/")[0];
+	return getPlatformObjectTypeFromJsonSchema(schema);
+};
+const isMatchingType = (schema, allowedTypes, allowedArrayTypes) => {
+	if (allowedTypes.length === 0) return true;
+	const jsonSchemaType = getJsonSchemaType(schema);
+	if (allowedTypes.some((schemaType) => schemaType === "string") && JsonSchemaStringifiableTypes.some((schemaType) => schemaType === jsonSchemaType)) return true;
+	else if (jsonSchemaType === JsonSchemaAllTypes.Array) {
+		const itemsSchema = "items" in schema ? schema.items : null;
+		if (!allowedTypes.includes(JsonSchemaAllTypes.Array) || allowedArrayTypes?.length && !allowedArrayTypes.some((schemaType) => schemaType === getJsonSchemaType(itemsSchema))) return false;
+	} else if (jsonSchemaType !== JsonSchemaAllTypes.Object && !allowedTypes.some((schemaType) => schemaType === jsonSchemaType)) return false;
+	return true;
+};
+const isValidOptionHelper = (schema, allowedFieldPaths, disallowedFieldPaths, allowedTypes, allowedArrayTypes, path, platformObjectJsonSchema, traversedSchemaIds = /* @__PURE__ */ new Set()) => {
+	const resolvedSchema = isJsonSchemaRef(schema) ? resolveJssRef(schema, platformObjectJsonSchema) : schema;
+	if (resolvedSchema.$id) if (traversedSchemaIds.has(resolvedSchema.$id)) return false;
+	else traversedSchemaIds.add(resolvedSchema.$id);
+	const dotPath = path.join(".");
+	if (disallowedFieldPaths.has(dotPath)) return false;
+	if (!isMatchingType(resolvedSchema, allowedTypes, allowedArrayTypes)) return false;
+	if (allowedFieldPaths.has(dotPath)) return true;
+	if (getJsonSchemaType(resolvedSchema) === "object") {
+		if ("fieldType" in resolvedSchema && isJsonType(resolvedSchema.fieldType)) return allowedFieldPaths.size === 0;
+		return "properties" in resolvedSchema && resolvedSchema.properties != null && Object.entries(resolvedSchema.properties).some(([prop, propSchema]) => isValidOptionHelper(propSchema, allowedFieldPaths, disallowedFieldPaths, allowedTypes, allowedArrayTypes, [...path, prop], platformObjectJsonSchema, traversedSchemaIds));
+	}
+	return allowedFieldPaths.size === 0;
+};
+const isValidOption = (schema, allowedFieldPaths, disallowedFieldPaths, allowedTypes, allowedArrayTypes, path = [], platformObjectJsonSchema) => {
+	const allowedFieldPathsSet = allowedFieldPaths == null ? /* @__PURE__ */ new Set() : new Set(allowedFieldPaths);
+	const disallowedFieldPathsSet = disallowedFieldPaths == null ? /* @__PURE__ */ new Set() : new Set(disallowedFieldPaths);
+	if (allowedFieldPathsSet.size === 0 && disallowedFieldPathsSet.size === 0 && allowedTypes.length === 0 && allowedArrayTypes.length === 0) return true;
+	return isValidOptionHelper(schema, allowedFieldPathsSet, disallowedFieldPathsSet, allowedTypes ?? [], allowedArrayTypes ?? [], path, platformObjectJsonSchema);
+};
+const buildSchemaOptionsFor = (rootSchema, baseChain) => Object.entries(rootSchema?.properties ?? {}).map(([property, propSchema]) => {
+	const appended = appendedMethodChain(baseChain ?? EMPTY_METHOD_CHAIN, property);
+	return {
+		label: methodChainToString(appended),
+		value: methodChainToString(appended),
+		property,
+		schema: propSchema,
+		methodChain: appended,
+		workflowObjectKey: "objectKey" in propSchema ? propSchema.objectKey : void 0,
+		isVariable: "isVariable" in propSchema ? propSchema.isVariable : false
+	};
+});
+const getSupportedArrayFunctions = (schema, arrayPrimitive) => {
+	if (isJsonSchemaArray(schema) && schema["supportedFunctions"]) return schema["supportedFunctions"];
+	return arrayPrimitive["baseSupportedFunctions"] ?? [];
+};
+const getSchemaOptions = ({ option, optionFilters, platformObjectJsonSchema, primitiveUtilities, digPrimitives = false }) => {
+	const { schema, methodChain } = option;
+	const nullableRefSchema = getNonNullableRefSchema(schema);
+	const baseSchema = nullableRefSchema ?? schema;
+	const refResolved = isJsonSchemaRef(baseSchema) ? resolveJssRef(baseSchema, platformObjectJsonSchema) : baseSchema;
+	const nonNullable = refResolved && getNonNullableType(refResolved);
+	const resolvedSchema = nonNullable ? {
+		...refResolved,
+		type: nonNullable
+	} : refResolved;
+	const schemaType = getJsonSchemaType(resolvedSchema);
+	const schemaOptions = (() => {
+		switch (schemaType) {
+			case JsonSchemaAllTypes.Object: return buildSchemaOptionsFor(resolvedSchema, methodChain);
+			case JsonSchemaAllTypes.Array:
+			case JsonSchemaAllTypes.MultiEnum: {
+				if (!digPrimitives) return [];
+				const arrayPrimitive = primitiveUtilities["/schema/array"];
+				if (!arrayPrimitive) return [];
+				const allOptions = buildSchemaOptionsFor(arrayPrimitive, methodChain);
+				const supported = getSupportedArrayFunctions(resolvedSchema, arrayPrimitive);
+				return allOptions.filter((opt) => supported.includes(opt.property));
+			}
+			case JsonSchemaAllTypes.String: return digPrimitives ? buildSchemaOptionsFor(primitiveUtilities["/schema/string"], methodChain) : [];
+			case JsonSchemaAllTypes.Enum:
+				if (digPrimitives && isJsonSchemaString(resolvedSchema)) return buildSchemaOptionsFor(primitiveUtilities["/schema/string"], methodChain);
+				return [];
+			case JsonSchemaAllTypes.File: return digPrimitives ? buildSchemaOptionsFor(primitiveUtilities["/schema/field/file"], methodChain) : [];
+			case JsonSchemaAllTypes.Integer:
+			case JsonSchemaAllTypes.Number: return digPrimitives && primitiveUtilities["/schema/number"] ? buildSchemaOptionsFor(primitiveUtilities["/schema/number"], methodChain) : [];
+			case JsonSchemaAllTypes.Boolean: return digPrimitives && primitiveUtilities["/schema/boolean"] ? buildSchemaOptionsFor(primitiveUtilities["/schema/boolean"], methodChain) : [];
+			case JsonSchemaAllTypes.Date: return digPrimitives && primitiveUtilities["/schema/date"] ? buildSchemaOptionsFor(primitiveUtilities["/schema/date"], methodChain) : [];
+			case JsonSchemaAllTypes.Datetime: return digPrimitives && primitiveUtilities["/schema/datetime"] ? buildSchemaOptionsFor(primitiveUtilities["/schema/datetime"], methodChain) : [];
+			case JsonSchemaAllTypes.GroupedEnum:
+			case JsonSchemaAllTypes.Null:
+			case JsonSchemaAllTypes.Relation:
+			case JsonSchemaAllTypes.MaskedString:
+			case JsonSchemaAllTypes.Unknown: return [];
+			default: assertNever(schemaType);
+		}
+	})();
+	const nullSafeOptions = nullableRefSchema != null || nonNullable != null ? schemaOptions.filter((opt) => {
+		if (isFunctionSchema(opt.schema) && opt.schema.codeChainFunctionToken != null) return opt.schema.acceptsNullReceiver === true;
+		return nullableRefSchema == null;
+	}) : schemaOptions;
+	return sortBy(optionFilters && !!flatten(compact(Object.values(optionFilters))).length ? filterForAllowedSchemaOptions(nullSafeOptions, optionFilters, platformObjectJsonSchema) : nullSafeOptions, (opt) => opt.property.replace(/^@/, ""));
+};
+const formatDisplayValue = (value) => {
+	return typeof value === "string" ? value : trim(JSON.stringify(value, null, 1), "\"");
+};
+/**
+* Resolves the schema at a dotted path (e.g. "account.birthDate").
+* Tries direct key lookup first, then traverses into nested object .properties by path part.
+* Normalizes kebab/snake at each level for key lookup.
+*/
+function getSchemaByPath(properties, path) {
+	if (!properties || !path) return;
+	const lookup = (props, key) => props[key] ?? props[key.replace(/_/g, "-")] ?? props[key.replace(/-/g, "_")];
+	const byFullPath = lookup(properties, path);
+	if (byFullPath != null) return byFullPath;
+	const i = path.indexOf(".");
+	if (i === -1) return;
+	const nestedKey = path.slice(0, i);
+	const rest = path.slice(i + 1);
+	const next = lookup(properties, nestedKey);
+	if (next == null || !isJsonSchemaObject(next) || !next.properties) return;
+	return getSchemaByPath(next.properties, rest);
+}
+const parseMethodChainForJSS = (path) => {
+	const { methodChain, partial, valid } = parseWithPartialOption(path);
+	if (!valid) return null;
+	if (partial.length > 0) return appendedMethodChain(methodChain, partial);
+	return methodChain;
+};
+const getSchemaForFieldPath = ({ path, initialSchema, platformObjectJsonSchema = {}, primitiveUtilities = {} }) => {
+	if (!initialSchema || !("type" in initialSchema) && !("$ref" in initialSchema)) return {
+		schema: null,
+		propertyName: null
+	};
+	const schema = isJsonSchemaRef(initialSchema) ? resolveJssRef(initialSchema, platformObjectJsonSchema) : initialSchema;
+	if (path === "" || !isValid(path)) return {
+		schema: null,
+		propertyName: null
+	};
+	const methodChain = parseMethodChain(path);
+	if (!methodChain) return {
+		schema: null,
+		propertyName: null
+	};
+	const result = methodChain.links.reduce((currentSchema, link) => {
+		return nextLinkSchema({
+			currentSchema,
+			nextLink: link,
+			platformObjectJsonSchema,
+			primitiveUtilities
+		});
+	}, schema);
+	return {
+		schema: result,
+		propertyName: result ? last(methodChain.links)?.name || null : null
+	};
+};
+/**
+* Get the schema for a variable path from usableObjects.
+*/
+const getSchemaForVariablePath = ({ path, usableObjects }) => {
+	return getSchemaForFieldPath({
+		path,
+		initialSchema: {
+			type: "object",
+			properties: Object.fromEntries(usableObjects.filter((obj) => obj.schema != null && obj.isVariable === true).map((obj) => [obj.value, obj.schema]))
+		}
+	});
+};
+const getPrimitiveSchemaId = (schema) => {
+	if (!("type" in schema)) return null;
+	if (isJsonSchemaObject(schema) && isFileType(schema.fieldType)) return "/schema/field/file";
+	if (isJsonSchemaDate(schema)) return "/schema/date";
+	if (isJsonSchemaDateTime(schema)) return "/schema/datetime";
+	const type = Array.isArray(schema.type) ? getNonNullableType(schema) : schema.type;
+	if (!type) return null;
+	if (type === "integer" || type === "number") return "/schema/number";
+	if (type === "boolean") return "/schema/boolean";
+	return getSchemaId(type);
+};
+const nextLinkSchema = ({ currentSchema, nextLink, platformObjectJsonSchema, primitiveUtilities }) => {
+	if (!currentSchema) return null;
+	if (nextLink.type === MethodChainNodeTypes.CustomFunction) {
+		const unwrapped = getNonNullableRefSchema(currentSchema);
+		const nonNullType = unwrapped ? null : getNonNullableType(currentSchema);
+		const receiver = unwrapped ?? (nonNullType ? {
+			...currentSchema,
+			type: nonNullType
+		} : null);
+		if (receiver) {
+			if (getFunctionSchemaForNode({
+				parentSchema: currentSchema,
+				functionName: fullNodeName(nextLink),
+				isCustomFunction: true,
+				platformObjectJsonSchema,
+				primitiveUtilities
+			})?.acceptsNullReceiver !== true) return null;
+			currentSchema = receiver;
+		}
+	}
+	if (isJsonSchemaRef(currentSchema)) currentSchema = resolveJssRef(currentSchema, platformObjectJsonSchema);
+	else if (isJsonSchemaArray(currentSchema) && isJsonSchemaRef(currentSchema.items)) currentSchema = {
+		...currentSchema,
+		items: { ...resolveJssRef(currentSchema.items, platformObjectJsonSchema) }
+	};
+	if (!("type" in currentSchema)) return null;
+	const schemaId = getPrimitiveSchemaId(currentSchema);
+	if (schemaId && schemaId in primitiveUtilities) {
+		const utilityReturnType = getPrimitiveUtilitiesReturnSchema(currentSchema, nextLink, primitiveUtilities[schemaId]);
+		if (utilityReturnType) return utilityReturnType;
+	}
+	if ("properties" in currentSchema) {
+		const propertySchema = currentSchema.properties[fullNodeName(nextLink)];
+		if (propertySchema && isFunctionSchema(propertySchema)) return propertySchema.properties.returnType;
+		return propertySchema ?? null;
+	}
+	return null;
+};
+/**
+* Returns the FunctionJsonSchema for `functionName` within `parentSchema`, checking both
+* primitive utilities (e.g. array/string methods) and direct object properties.
+* Returns null if not found or not a function schema.
+*/
+const getFunctionSchemaForNode = ({ parentSchema, functionName, isCustomFunction, platformObjectJsonSchema, primitiveUtilities }) => {
+	if (isCustomFunction) parentSchema = getNonNullableRefSchema(parentSchema) ?? parentSchema;
+	if (isJsonSchemaRef(parentSchema)) parentSchema = resolveJssRef(parentSchema, platformObjectJsonSchema);
+	const schemaId = getPrimitiveSchemaId(parentSchema);
+	if (schemaId && schemaId in primitiveUtilities) {
+		const utilitySchema = primitiveUtilities[schemaId].properties[functionName];
+		if (utilitySchema && isFunctionSchema(utilitySchema)) return utilitySchema;
+	}
+	if (isJsonSchemaObject(parentSchema) && functionName in parentSchema.properties) {
+		const propSchema = parentSchema.properties[functionName];
+		if (isFunctionSchema(propSchema)) return propSchema;
+	}
+	return null;
+};
+const injectRefForPlatformObjectArray = (schema) => {
+	if (schema && isJsonSchemaArray(schema) && isJsonSchemaObject(schema.items) && "objectKey" in schema.items && schema.items.objectKey) {
+		const schemaId = getSchemaId(schema.items.objectKey, MERGED_SCHEMA_ID);
+		return {
+			...schema,
+			items: {
+				...schema.items,
+				$ref: schemaId
+			}
+		};
+	}
+	return schema;
+};
+const getPrimitiveUtilitiesReturnSchema = (object, node, schema) => {
+	const name = fullNodeName(node);
+	if (!(name in schema.properties)) return null;
+	const utilitySchema = schema.properties[name];
+	const returnSchema = isFunctionSchema(utilitySchema) ? utilitySchema.properties.returnType : utilitySchema;
+	const itemSchema = genericArrayItemSchema(object, returnSchema);
+	if (itemSchema) return itemSchema;
+	if (isPrecedingSchema(returnSchema)) return object;
+	if (isConvertedTypeSchema(returnSchema) && isFunctionNode(node) && node.params[returnSchema.position] && isStringNode(node.params[returnSchema.position])) {
+		const stringNode = node.params[returnSchema.position];
+		return returnSchema.schemaByValue[stringNode.value] ?? EMPTY_JSON_SCHEMA_OBJECT;
+	}
+	if (isGenericParameterSchema(returnSchema) && isFunctionNode(node) && node.params[returnSchema.position] && isStringNode(node.params[returnSchema.position])) {
+		const stringNode = node.params[returnSchema.position];
+		const objectSchema = isJsonSchemaArray(object) ? object.items : object;
+		if (isJsonSchemaObject(objectSchema)) return injectRefForPlatformObjectArray(stringNode.value.split(".").reduce((schema, key) => {
+			if (schema == null || !isJsonSchemaObject(schema) || !schema.properties[key]) return null;
+			return schema.properties[key];
+		}, objectSchema));
+	}
+	return "genericType" in returnSchema ? EMPTY_JSON_SCHEMA_OBJECT : returnSchema;
+};
+/**
+* @param path
+* @param allowedFieldPaths - can be a complete path to a base type field
+* (e.g. 'data.some.string_field'), or a partial path to an object ('data')
+* @param fieldPathsAreStrictMatch - true if we only want to match exact paths in allowedFieldPaths and disallowedFieldPaths
+*/
+const isAllowedPath = (path, allowedFieldPaths) => {
+	return allowedFieldPaths.some((fieldPath) => {
+		const valueIsPartialMatch = fieldPath.startsWith(path);
+		const valueIsNestedProp = path.startsWith(`${fieldPath}.`);
+		return valueIsPartialMatch || valueIsNestedProp;
+	});
+};
+/**
+* @param path
+* @param disallowedFieldPaths - can be a complete path to a base type field
+* (e.g. 'data.some.string_field'), or a partial path to an object ('data')
+*/
+const isDisallowedPath = (path, disallowedFieldPaths) => {
+	return disallowedFieldPaths.some((fieldPath) => {
+		const valueIsMatch = fieldPath === path;
+		const valueIsNestedProp = path.startsWith(`${fieldPath}.`);
+		return valueIsMatch || valueIsNestedProp;
+	});
+};
+const isTypeMatch = ({ fieldJsonSchema, types, platformObjectJsonSchema = {}, arrayTypes, traversedSchemaIds = /* @__PURE__ */ new Set() }) => {
+	const resolvedSchema = isJsonSchemaRef(fieldJsonSchema) ? resolveJssRef(fieldJsonSchema, platformObjectJsonSchema) : fieldJsonSchema;
+	if (resolvedSchema.$id) if (traversedSchemaIds.has(resolvedSchema.$id)) return false;
+	else traversedSchemaIds.add(resolvedSchema.$id);
+	const fieldJsonSchemaType = getJsonSchemaType(resolvedSchema);
+	switch (fieldJsonSchemaType) {
+		case JsonSchemaAllTypes.Object: {
+			const objectSchema = resolvedSchema;
+			const isObjectKeyOfType = (type) => objectSchema.objectKey && types.includes(type) && objectSchema.objectKey.split("/")[0] === type;
+			if (types.includes("object") || objectSchema.objectKey && types.includes(objectSchema.objectKey) || isObjectKeyOfType("report") || isObjectKeyOfType("verification")) return true;
+			return Object.values(objectSchema.properties || {}).some((propJsonSchema) => isTypeMatch({
+				fieldJsonSchema: propJsonSchema,
+				types,
+				platformObjectJsonSchema,
+				arrayTypes,
+				traversedSchemaIds
+			}));
+		}
+		case JsonSchemaAllTypes.Array: {
+			const arraySchema = resolvedSchema;
+			const itemSchema = isJsonSchemaRef(arraySchema.items) ? resolveJssRef(arraySchema.items, platformObjectJsonSchema) : arraySchema.items;
+			return types.includes(JsonSchemaAllTypes.Array) && !!arrayTypes && arrayTypes.some((schemaType) => schemaType === getJsonSchemaType(itemSchema) || isJsonSchemaObject(itemSchema) && schemaType === itemSchema.objectKey);
+		}
+		case JsonSchemaAllTypes.String:
+		case JsonSchemaAllTypes.Number:
+		case JsonSchemaAllTypes.Boolean:
+		case JsonSchemaAllTypes.Integer:
+		case JsonSchemaAllTypes.Date:
+		case JsonSchemaAllTypes.Datetime:
+		case JsonSchemaAllTypes.Enum:
+		case JsonSchemaAllTypes.MultiEnum:
+		case JsonSchemaAllTypes.GroupedEnum:
+		case JsonSchemaAllTypes.Unknown: return types.some((schemaType) => schemaType === fieldJsonSchemaType);
+		default: return false;
+	}
+};
+const hasRequiredPropertyShape = (schema, requiredPropertyShape, platformObjectJsonSchema = {}, checkRecursively = true) => {
+	if (!requiredPropertyShape?.length) return true;
+	const resolvedSchema = isJsonSchemaRef(schema) ? resolveJssRef(schema, platformObjectJsonSchema) : schema;
+	if (resolvedSchema && "type" in resolvedSchema && resolvedSchema.type === "object" && "properties" in resolvedSchema && resolvedSchema.properties) {
+		const schemaProperties = resolvedSchema.properties;
+		if (requiredPropertyShape.every((propName) => propName in schemaProperties)) return true;
+		if (checkRecursively) return Object.values(schemaProperties).some((propSchema) => hasRequiredPropertyShape(propSchema, requiredPropertyShape, platformObjectJsonSchema, checkRecursively));
+	}
+	return false;
+};
+const filterForAllowedSchemaOptions = (options = [], { allowedArrayTypes, allowedFieldPaths, allowedTypes, disallowedFieldPaths, fieldPathsAreStrictMatch, requiredPropertyShape }, platformObjectJsonSchema = {}) => {
+	let filteredOptions = options;
+	if (fieldPathsAreStrictMatch) {
+		if (allowedFieldPaths?.length || disallowedFieldPaths?.length || allowedTypes?.length) filteredOptions = filteredOptions.filter((option) => isValidOption(option.schema, allowedFieldPaths ?? [], disallowedFieldPaths ?? [], allowedTypes ?? [], allowedArrayTypes ?? [], option.value.split("."), platformObjectJsonSchema));
+	} else {
+		if (allowedFieldPaths?.length) filteredOptions = filteredOptions.filter((option) => isAllowedPath(option.value, allowedFieldPaths));
+		if (disallowedFieldPaths?.length) filteredOptions = filteredOptions.filter((option) => !isDisallowedPath(option.value, disallowedFieldPaths));
+		if (allowedTypes?.length) filteredOptions = filteredOptions.filter((option) => isTypeMatch({
+			fieldJsonSchema: option.schema,
+			types: allowedTypes,
+			platformObjectJsonSchema,
+			arrayTypes: allowedArrayTypes
+		}));
+	}
+	if (requiredPropertyShape?.length) filteredOptions = filteredOptions.filter((option) => hasRequiredPropertyShape(option.schema, requiredPropertyShape, platformObjectJsonSchema));
+	return filteredOptions;
+};
+const getOptionForValue = ({ value, jsonSchema, schemaForFieldPath }) => {
+	const { schema, propertyName } = schemaForFieldPath(value, jsonSchema);
+	if (!schema || !propertyName) return null;
+	const methodChain = parseMethodChainForJSS(value);
+	return {
+		label: methodChain ? methodChainToString(methodChain) : value,
+		value: methodChain ? methodChainToString(methodChain) : value,
+		property: propertyName,
+		schema,
+		methodChain
+	};
+};
+const validatePath = ({ path, jsonSchema, platformObjectJsonSchema = {}, primitiveUtilities = {}, optionFilters }) => {
+	const schemaOptions = getSchemaOptions({
+		option: {
+			schema: jsonSchema,
+			methodChain: parseMethodChainForJSS("")
+		},
+		optionFilters,
+		platformObjectJsonSchema,
+		primitiveUtilities
+	});
+	const { methodChain, partial } = parseWithPartialOption(path);
+	const optionsWithPartiallyMatchedFinalLink = methodChain.links.reduce((currentSchema, link) => {
+		if (currentSchema.length === 0) return [];
+		const optionMatch = currentSchema.find((option) => option.property === link.name);
+		if (optionMatch) return getSchemaOptions({
+			option: optionMatch,
+			optionFilters,
+			platformObjectJsonSchema,
+			primitiveUtilities
+		});
+		return [];
+	}, schemaOptions).filter((option) => option.property.includes(partial));
+	return {
+		valid: optionsWithPartiallyMatchedFinalLink.length > 0,
+		schemaOptions: optionsWithPartiallyMatchedFinalLink,
+		partial
+	};
+};
+/**
+* Given a method chain that corresponds to the passed schema, find the right-most indentifier that
+* is a platform object and split the method chain on that identifier, with the platform object on
+* the left side.
+*
+* This function is used to optimize a method chain into two parts, left side for server resolution
+* and right side for client resolution.
+*
+* For example:
+* current_case.fields.field_a -> ['current_case', 'fields.field_a']
+* current_case.inquiries.first.id -> ['current_case.inquiries.first', 'id']
+* current_case.account.fields.field_b -> ['current_case.account', 'fields.field_b']
+*/
+const splitAtNearestParentObject = (chain, currentSchema, platformSchemaMap, primitiveUtilities) => {
+	const leafUpLinkSchemas = [currentSchema];
+	for (const link of chain.links) {
+		const nextSchema = nextLinkSchema({
+			currentSchema: leafUpLinkSchemas[0],
+			nextLink: link,
+			platformObjectJsonSchema: platformSchemaMap,
+			primitiveUtilities
+		});
+		leafUpLinkSchemas.unshift(nextSchema);
+	}
+	const leafUpLeftLinks = [...chain.links].reverse();
+	const leafUpRightLinks = [];
+	for (const [i, linkSchema] of leafUpLinkSchemas.entries()) {
+		if (!linkSchema) {
+			if (isIdentifierNode(leafUpLeftLinks[0])) {
+				if (leafUpLinkSchemas.slice(i + 1).find((s) => s && (isJsonSchemaRef(s) || isJsonSchemaArray(s) && isJsonSchemaRef(s.items)))) {
+					leafUpRightLinks.push(leafUpLeftLinks.shift());
+					continue;
+				}
+			}
+			break;
+		} else if ("$id" in linkSchema || isJsonSchemaRef(linkSchema)) break;
+		else if (isJsonSchemaArray(linkSchema)) {
+			if ("$id" in linkSchema.items || isJsonSchemaRef(linkSchema.items)) break;
+			if (isFunctionNode(leafUpLeftLinks[0])) break;
+		} else if (isFunctionNode(leafUpLeftLinks[0])) break;
+		else if (isIdentifierNode(leafUpLeftLinks[0])) {
+			const nextSchema = leafUpLinkSchemas[i + 1];
+			if (nextSchema) {
+				const primitiveId = getPrimitiveSchemaId(nextSchema);
+				if (primitiveId && primitiveId in primitiveUtilities) break;
+			}
+			if (nextSchema && isJsonSchemaArray(nextSchema)) break;
+		}
+		leafUpRightLinks.push(leafUpLeftLinks.shift());
+	}
+	return [{
+		type: MethodChainNodeTypes.Chain,
+		links: leafUpLeftLinks.reverse()
+	}, {
+		type: MethodChainNodeTypes.Chain,
+		links: leafUpRightLinks.reverse()
+	}];
+};
+//#endregion
+export { extractPlatformObjectKey, formatDisplayValue, getFunctionSchemaForNode, getOptionForValue, getSchemaByPath, getSchemaForFieldPath, getSchemaForVariablePath, getSchemaOptions, hasRequiredPropertyShape, isTypeMatch, isValidOption, nextLinkSchema, splitAtNearestParentObject, validatePath };
+
+//# sourceMappingURL=schemaOptions.mjs.map