@persona/design-system 0.7.2 → 0.8.1

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-L_h8Z8Bx.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

package/dist/lib/schemaOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaOptions.mjs","names":[],"sources":["../../lib/schemaOptions.ts"],"sourcesContent":["import { compact, flatten, last, sortBy, trim } from 'lodash-es';\n\nimport { assertNever } from './assertNever';\nimport {\n  JsonSchemaAllTypes,\n  type JsonSchemaCustomTypes,\n  JsonSchemaStringifiableTypes,\n  EMPTY_JSON_SCHEMA_OBJECT,\n  getNonNullableRefSchema,\n  genericArrayItemSchema,\n  getNonNullableType,\n  isConvertedTypeSchema,\n  isFileType,\n  isFunctionSchema,\n  isGenericParameterSchema,\n  isJsonSchemaArray,\n  isJsonSchemaDate,\n  isJsonSchemaDateTime,\n  isJsonSchemaObject,\n  isJsonSchemaRef,\n  isJsonSchemaString,\n  isJsonType,\n  isPrecedingSchema,\n  type JsonSchema,\n  type JsonSchemaArray,\n  type JsonSchemaBasicTypes,\n  type JsonSchemaObject,\n  JsonSchemaTypes,\n  type JsonSchemaObjectKey,\n} from './jsonSchema';\nimport { getJsonSchemaType } from './jsonSchemaType';\nimport {\n  appendedMethodChain,\n  type Chain,\n  EMPTY_METHOD_CHAIN,\n  isIdentifierNode,\n  isFunctionNode,\n  isStringNode,\n  isValid,\n  type MethodChainNode,\n  MethodChainNodeTypes,\n  methodChainToString,\n  parseMethodChain,\n  parseWithPartialOption,\n  type StringNode,\n} from './methodChain';\nimport type { FunctionJsonSchema, ObjectSchemaMap } from './objectSchemaTypes';\nimport {\n  getPlatformObjectTypeFromJsonSchema,\n  getSchemaId,\n  MERGED_SCHEMA_ID,\n  PrimitiveSchemaId,\n  resolveJssRef,\n} from './platformObject';\n\ntype VariableSchemaObject = {\n  value: string;\n  schema?: JsonSchema | null;\n  isVariable?: boolean;\n};\n\nconst fullNodeName = (node: MethodChainNode): string =>\n  `${node.type === MethodChainNodeTypes.CustomFunction ? '@' : ''}${node.name}`;\n\nexport type Option = {\n  label: string;\n  value: string;\n  property: string;\n  schema: JsonSchema | FunctionJsonSchema;\n  methodChain: Chain | null;\n  utility?: boolean;\n  workflowObjectKey?: string;\n  isVariable?: boolean;\n};\n\nconst SCHEMA_PATH_PATTERN = /\\/schema\\/([a-z][a-z0-9-_]*)/i;\n\n/**\n * Extracts the top-level platform-object key from a schema's `$ref`/`$id`/\n * `objectKey`/`objectType.const` markers. Collapses subtypes to their root\n * (`/schema/verification/document/merged` -> `verification`) because callers\n * compare against top-level `ApiModel` values.\n */\nexport const extractPlatformObjectKey = (\n  schema: JsonSchema | null | undefined,\n  platformObjectJsonSchema: ObjectSchemaMap = {},\n): string | null => {\n  if (!schema) {\n    return null;\n  }\n  if (isJsonSchemaRef(schema)) {\n    const refMatch = schema.$ref?.match(SCHEMA_PATH_PATTERN);\n    if (refMatch) {\n      return refMatch[1];\n    }\n    return extractPlatformObjectKey(\n      resolveJssRef(schema, platformObjectJsonSchema),\n      platformObjectJsonSchema,\n    );\n  }\n  if ('$id' in schema && typeof schema.$id === 'string') {\n    const idMatch = schema.$id.match(SCHEMA_PATH_PATTERN);\n    if (idMatch) {\n      return idMatch[1];\n    }\n  }\n  // Serialized PLOB columns carry `objectKey` on a scalar schema (no `$ref`), so\n  // read it regardless of `type`, collapsing subtypes to root like the `$ref` branch.\n  if ('objectKey' in schema && typeof schema.objectKey === 'string') {\n    return schema.objectKey.split('/')[0];\n  }\n  return getPlatformObjectTypeFromJsonSchema(schema);\n};\n\ntype PossibleType = JsonSchemaTypes | JsonSchemaCustomTypes | JsonSchemaObjectKey;\ntype PossibleArrayType = JsonSchemaBasicTypes | JsonSchemaTypes.Object | JsonSchemaObjectKey;\n\nconst isMatchingType = (\n  schema: JsonSchema,\n  allowedTypes: PossibleType[],\n  allowedArrayTypes: PossibleArrayType[],\n) => {\n  if (allowedTypes.length === 0) {\n    return true;\n  }\n  const jsonSchemaType = getJsonSchemaType(schema);\n  // If strings are allowed and the field is string-able, let it through.\n  if (\n    allowedTypes.some((schemaType) => schemaType === JsonSchemaTypes.String) &&\n    JsonSchemaStringifiableTypes.some((schemaType) => schemaType === jsonSchemaType)\n  ) {\n    return true;\n  } else if (jsonSchemaType === JsonSchemaAllTypes.Array) {\n    const itemsSchema = 'items' in schema ? schema.items : null;\n    if (\n      !allowedTypes.includes(JsonSchemaAllTypes.Array) ||\n      // Don't recurse on array, otherwise we risk matching on objects within the array\n      (allowedArrayTypes?.length &&\n        !allowedArrayTypes.some((schemaType) => schemaType === getJsonSchemaType(itemsSchema)))\n    ) {\n      return false;\n    }\n  } else if (\n    jsonSchemaType !== JsonSchemaAllTypes.Object &&\n    !allowedTypes.some((schemaType) => schemaType === jsonSchemaType)\n  ) {\n    return false;\n  }\n  return true;\n};\n\n// isValidOptionHelper returns true if the schema provided is (in order of precedence)\n// 1) not a disallowed by name\n// AND 2) not a disallowed type\n// AND 3) allowed field by name (either explicitly or implicitly)\n// at each level (we recurse down for object types), we check that the fields at the level fit the above 1,2 and 3\n//\n// 1) is straight forward. if a field is named as disallowed it has the most precedence\n// 2) the field is disallowed by type if the allowedTypes are specified AND\n//    - if the field is an array, then\n//       - arrays are in allowedTypes\n//       - AND (its `items` type is in `allowedArrayTypes` OR `allowedArrayTypes` is empty)\n//    - if the field is an object, we do nothing since the recursion is handled at the `isValidOptionHelper` level\n//    - else, the field type appears in allowedTypes\n// 3) we can be allowed by name\n//    - explicitly, which means the field is named explicitly as an allowedFieldPath (this has precedence)\n//    - implicitly, which means that there are no fields explicitly named in allowedFieldPath\n//      - an object field can be allowed implicitly if it has at least one valid children\nconst isValidOptionHelper = (\n  schema: JsonSchema,\n  allowedFieldPaths: Set<string>,\n  disallowedFieldPaths: Set<string>,\n  allowedTypes: PossibleType[],\n  allowedArrayTypes: PossibleArrayType[],\n  path: string[],\n  platformObjectJsonSchema: ObjectSchemaMap,\n  traversedSchemaIds = new Set(),\n): boolean => {\n  const resolvedSchema = isJsonSchemaRef(schema)\n    ? resolveJssRef(schema, platformObjectJsonSchema)\n    : schema;\n\n  if (resolvedSchema.$id) {\n    if (traversedSchemaIds.has(resolvedSchema.$id)) {\n      // We've already traversed this schema ID, which there were no\n      // valid types found for it, so return false to avoid infinite loops\n      return false;\n    } else {\n      // If we haven't traversed this schema ID yet, add it to the set\n      // This allows us to avoid infinite loops when resolving references\n      // in recursive schemas\n      traversedSchemaIds.add(resolvedSchema.$id);\n    }\n  }\n  const dotPath = path.join('.');\n  if (disallowedFieldPaths.has(dotPath)) {\n    return false;\n  }\n  if (!isMatchingType(resolvedSchema, allowedTypes, allowedArrayTypes)) {\n    return false;\n  }\n  if (allowedFieldPaths.has(dotPath)) {\n    return true;\n  }\n  // if we are here it means\n  // - our type is valid\n  // - we are not disallowed\n  // - we are not explicitly allowed\n  // if we are here, we are only valid if\n  // - we are an object and at least one of our properties are valid\n  // OR, we are not an object and allowedFieldPaths is empty\n  const jsonSchemaType = getJsonSchemaType(resolvedSchema);\n  if (jsonSchemaType === JsonSchemaTypes.Object) {\n    // A schemaless JSON field is an opaque leaf, so it has no child to qualify it as an option.\n    if ('fieldType' in resolvedSchema && isJsonType(resolvedSchema.fieldType)) {\n      return allowedFieldPaths.size === 0;\n    }\n    return (\n      'properties' in resolvedSchema &&\n      resolvedSchema.properties != null &&\n      Object.entries(resolvedSchema.properties).some(([prop, propSchema]) =>\n        isValidOptionHelper(\n          propSchema,\n          allowedFieldPaths,\n          disallowedFieldPaths,\n          allowedTypes,\n          allowedArrayTypes,\n          [...path, prop],\n          platformObjectJsonSchema,\n          traversedSchemaIds,\n        ),\n      )\n    );\n  }\n  return allowedFieldPaths.size === 0;\n};\n\nexport const isValidOption = (\n  schema: JsonSchema,\n  allowedFieldPaths: string[],\n  disallowedFieldPaths: string[],\n  allowedTypes: PossibleType[],\n  allowedArrayTypes: PossibleArrayType[],\n  path: string[] = [],\n  platformObjectJsonSchema: ObjectSchemaMap,\n): boolean => {\n  const allowedFieldPathsSet =\n    allowedFieldPaths == null ? new Set<string>() : new Set<string>(allowedFieldPaths);\n  const disallowedFieldPathsSet =\n    disallowedFieldPaths == null ? new Set<string>() : new Set<string>(disallowedFieldPaths);\n  if (\n    allowedFieldPathsSet.size === 0 &&\n    disallowedFieldPathsSet.size === 0 &&\n    allowedTypes.length === 0 &&\n    allowedArrayTypes.length === 0\n  ) {\n    return true;\n  }\n  return isValidOptionHelper(\n    schema,\n    allowedFieldPathsSet,\n    disallowedFieldPathsSet,\n    allowedTypes ?? [],\n    allowedArrayTypes ?? [],\n    path,\n    platformObjectJsonSchema,\n  );\n};\n\nconst buildSchemaOptionsFor = (rootSchema: JsonSchemaObject, baseChain: Chain | null) =>\n  Object.entries(rootSchema?.properties ?? {}).map(([property, propSchema]) => {\n    const appended = appendedMethodChain(baseChain ?? EMPTY_METHOD_CHAIN, property);\n    return {\n      label: methodChainToString(appended),\n      value: methodChainToString(appended),\n      property,\n      schema: propSchema,\n      methodChain: appended,\n      workflowObjectKey: 'objectKey' in propSchema ? propSchema.objectKey : undefined,\n      isVariable: 'isVariable' in propSchema ? propSchema.isVariable : false,\n    };\n  });\n\nconst getSupportedArrayFunctions = (\n  schema: JsonSchema,\n  arrayPrimitive: JsonSchemaObject,\n): string[] => {\n  if (isJsonSchemaArray(schema) && schema['supportedFunctions']) {\n    return schema['supportedFunctions'];\n  }\n  return arrayPrimitive['baseSupportedFunctions'] ?? [];\n};\n\nexport const getSchemaOptions = ({\n  option,\n  optionFilters,\n  platformObjectJsonSchema,\n  primitiveUtilities,\n  digPrimitives = false,\n}: {\n  option: Pick<Option, 'schema' | 'methodChain'>;\n  optionFilters?: OptionFilters;\n  platformObjectJsonSchema: ObjectSchemaMap;\n  primitiveUtilities: ObjectSchemaMap;\n  digPrimitives?: boolean;\n}): Option[] => {\n  const { schema, methodChain } = option;\n  const nullableRefSchema = getNonNullableRefSchema(schema);\n  const baseSchema = nullableRefSchema ?? schema;\n  const refResolved = isJsonSchemaRef(baseSchema)\n    ? resolveJssRef(baseSchema, platformObjectJsonSchema)\n    : baseSchema;\n  const nonNullable = refResolved && getNonNullableType(refResolved);\n  const resolvedSchema = nonNullable\n    ? ({ ...refResolved, type: nonNullable } as JsonSchema)\n    : refResolved;\n  const schemaType = getJsonSchemaType(resolvedSchema);\n\n  const schemaOptions = (() => {\n    switch (schemaType) {\n      case JsonSchemaAllTypes.Object:\n        return buildSchemaOptionsFor(resolvedSchema as JsonSchemaObject, methodChain);\n      case JsonSchemaAllTypes.Array:\n      case JsonSchemaAllTypes.MultiEnum: {\n        if (!digPrimitives) {\n          return [];\n        }\n        const arrayPrimitive = primitiveUtilities[PrimitiveSchemaId.Array];\n        if (!arrayPrimitive) {\n          return [];\n        }\n        const allOptions = buildSchemaOptionsFor(arrayPrimitive, methodChain);\n        const supported = getSupportedArrayFunctions(resolvedSchema, arrayPrimitive);\n        return allOptions.filter((opt) => supported.includes(opt.property));\n      }\n      case JsonSchemaAllTypes.String:\n        return digPrimitives\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.String], methodChain)\n          : [];\n      case JsonSchemaAllTypes.Enum: {\n        if (digPrimitives && isJsonSchemaString(resolvedSchema)) {\n          return buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.String], methodChain);\n        }\n        return [];\n      }\n      case JsonSchemaAllTypes.File:\n        return digPrimitives\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.File], methodChain)\n          : [];\n      // Integer/Number share a single /schema/number bucket — see the collapse\n      // in `getPrimitiveSchemaId` and the backend `JSON_TYPE_TO_SCHEMA_ID`. The\n      // default mock primitives don't ship utilities for these, so the lookup\n      // returns CCFs only (the only properties merged in by `useChain`).\n      case JsonSchemaAllTypes.Integer:\n      case JsonSchemaAllTypes.Number:\n        return digPrimitives && primitiveUtilities[PrimitiveSchemaId.Number]\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.Number], methodChain)\n          : [];\n      case JsonSchemaAllTypes.Boolean:\n        return digPrimitives && primitiveUtilities[PrimitiveSchemaId.Boolean]\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.Boolean], methodChain)\n          : [];\n      // Date and Datetime are distinct buckets, mirroring the backend\n      // `PlatformPrimitive::Date` / `PlatformPrimitive::Datetime` split. A\n      // calendar-only Date receiver shouldn't surface CCFs authored against\n      // timezone-bearing Datetimes (or vice versa).\n      case JsonSchemaAllTypes.Date:\n        return digPrimitives && primitiveUtilities[PrimitiveSchemaId.Date]\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.Date], methodChain)\n          : [];\n      case JsonSchemaAllTypes.Datetime:\n        return digPrimitives && primitiveUtilities[PrimitiveSchemaId.Datetime]\n          ? buildSchemaOptionsFor(primitiveUtilities[PrimitiveSchemaId.Datetime], methodChain)\n          : [];\n      case JsonSchemaAllTypes.GroupedEnum:\n      case JsonSchemaAllTypes.Null:\n      case JsonSchemaAllTypes.Relation:\n      case JsonSchemaAllTypes.MaskedString:\n      case JsonSchemaAllTypes.Unknown:\n        return [];\n      default:\n        assertNever(schemaType);\n    }\n  })();\n\n  // After a possibly-null value, offer a CCF only when its receiver schema\n  // accepts null. Non-CCF members stay for nullable `type` arrays but not\n  // for a nullable `$ref | null` union, whose member paths `nextLinkSchema`\n  // cannot resolve.\n  const possiblyNull = nullableRefSchema != null || nonNullable != null;\n  const nullSafeOptions = possiblyNull\n    ? schemaOptions.filter((opt) => {\n        if (isFunctionSchema(opt.schema) && opt.schema.codeChainFunctionToken != null) {\n          return opt.schema.acceptsNullReceiver === true;\n        }\n        return nullableRefSchema == null;\n      })\n    : schemaOptions;\n\n  const containsFilters = optionFilters && !!flatten(compact(Object.values(optionFilters))).length;\n  const finalOptions = containsFilters\n    ? filterForAllowedSchemaOptions(nullSafeOptions, optionFilters, platformObjectJsonSchema)\n    : nullSafeOptions;\n  return sortBy(finalOptions, (opt: Option) => opt.property.replace(/^@/, '')) as Option[];\n};\n\nexport const formatDisplayValue = (value: any) => {\n  return typeof value === 'string' ? value : trim(JSON.stringify(value, null, 1), '\"');\n};\n\n/**\n * Resolves the schema at a dotted path (e.g. \"account.birthDate\").\n * Tries direct key lookup first, then traverses into nested object .properties by path part.\n * Normalizes kebab/snake at each level for key lookup.\n */\nexport function getSchemaByPath(\n  properties: Record<string, JsonSchema> | null | undefined,\n  path: string,\n): JsonSchema | undefined {\n  if (!properties || !path) {\n    return undefined;\n  }\n\n  const lookup = (props: Record<string, JsonSchema>, key: string): JsonSchema | undefined =>\n    props[key] ?? props[key.replace(/_/g, '-')] ?? props[key.replace(/-/g, '_')];\n\n  const byFullPath = lookup(properties, path);\n  if (byFullPath != null) {\n    return byFullPath;\n  }\n\n  const i = path.indexOf('.');\n  if (i === -1) {\n    return undefined;\n  }\n  const nestedKey = path.slice(0, i);\n  const rest = path.slice(i + 1);\n  const next = lookup(properties, nestedKey);\n  if (next == null || !isJsonSchemaObject(next) || !next.properties) {\n    return undefined;\n  }\n  return getSchemaByPath(next.properties, rest);\n}\n\nconst parseMethodChainForJSS = (path: string): Chain | null => {\n  const { methodChain, partial, valid } = parseWithPartialOption(path);\n  if (!valid) {\n    return null;\n  }\n\n  if (partial.length > 0) {\n    return appendedMethodChain(methodChain, partial);\n  }\n\n  return methodChain;\n};\n\nexport const getSchemaForFieldPath = ({\n  path,\n  initialSchema,\n  platformObjectJsonSchema = {},\n  primitiveUtilities = {},\n}: {\n  path: string;\n  initialSchema: JsonSchema;\n  platformObjectJsonSchema?: ObjectSchemaMap;\n  primitiveUtilities?: ObjectSchemaMap;\n}): {\n  schema: JsonSchema | null;\n  propertyName: string | null;\n} => {\n  if (!initialSchema || (!('type' in initialSchema) && !('$ref' in initialSchema))) {\n    return { schema: null, propertyName: null };\n  }\n\n  const schema: JsonSchema = isJsonSchemaRef(initialSchema)\n    ? resolveJssRef(initialSchema, platformObjectJsonSchema)\n    : initialSchema;\n\n  if (path === '' || !isValid(path)) {\n    return { schema: null, propertyName: null };\n  }\n  const methodChain = parseMethodChain(path);\n  if (!methodChain) {\n    return { schema: null, propertyName: null };\n  }\n  const result = methodChain.links.reduce<JsonSchema | null>((currentSchema, link) => {\n    return nextLinkSchema({\n      currentSchema,\n      nextLink: link,\n      platformObjectJsonSchema,\n      primitiveUtilities,\n    });\n  }, schema);\n\n  const propertyName = result ? last(methodChain.links)?.name || null : null;\n  return { schema: result, propertyName };\n};\n\n/**\n * Get the schema for a variable path from usableObjects.\n */\nexport const getSchemaForVariablePath = ({\n  path,\n  usableObjects,\n}: {\n  path: string;\n  usableObjects: VariableSchemaObject[];\n}): {\n  schema: JsonSchema | null;\n  propertyName: string | null;\n} => {\n  // just variables\n  const syntheticSchema: JsonSchemaObject = {\n    type: JsonSchemaTypes.Object,\n    properties: Object.fromEntries(\n      usableObjects\n        .filter((obj) => obj.schema != null && obj.isVariable === true)\n        .map((obj) => [obj.value, obj.schema!]),\n    ),\n  };\n\n  return getSchemaForFieldPath({\n    path,\n    initialSchema: syntheticSchema,\n  });\n};\n\nconst getPrimitiveSchemaId = (schema: JsonSchema): string | null => {\n  if (!('type' in schema)) {\n    return null;\n  }\n  // File type has special naming: 'file' -> '/schema/field/file'\n  // because the backend uses Field::File.name.underscore = 'field/file'\n  // File fields have type: 'object' with fieldType: 'file'\n  if (isJsonSchemaObject(schema) && isFileType(schema.fieldType)) {\n    return PrimitiveSchemaId.File;\n  }\n  // Date and Datetime are encoded as `{type: 'string', format: 'date'|'date-time'}`.\n  // Check before the generic string branch so date receivers don't bucket as String.\n  if (isJsonSchemaDate(schema)) {\n    return PrimitiveSchemaId.Date;\n  }\n  if (isJsonSchemaDateTime(schema)) {\n    return PrimitiveSchemaId.Datetime;\n  }\n  const type = Array.isArray(schema.type) ? getNonNullableType(schema) : schema.type;\n  if (!type) {\n    return null;\n  }\n  // Integer and Number share one CCF bucket — mirrors the backend collapse\n  // in JSON_TYPE_TO_SCHEMA_ID. A CCF authored against a Number receiver\n  // fires for both .length-style integers and float-typed values.\n  if (type === JsonSchemaTypes.Integer || type === JsonSchemaTypes.Number) {\n    return PrimitiveSchemaId.Number;\n  }\n  if (type === JsonSchemaTypes.Boolean) {\n    return PrimitiveSchemaId.Boolean;\n  }\n  return getSchemaId(type);\n};\n\nexport const nextLinkSchema = ({\n  currentSchema,\n  nextLink,\n  platformObjectJsonSchema,\n  primitiveUtilities,\n}: {\n  currentSchema: JsonSchema | null;\n  nextLink: MethodChainNode;\n  platformObjectJsonSchema: ObjectSchemaMap;\n  primitiveUtilities: ObjectSchemaMap;\n}): JsonSchema | null => {\n  if (!currentSchema) {\n    return null;\n  }\n  // Runtime dispatches a typed null only to a CCF whose receiver schema\n  // accepts null, so a nullable value resolves only through such CCFs.\n  if (nextLink.type === MethodChainNodeTypes.CustomFunction) {\n    const unwrapped = getNonNullableRefSchema(currentSchema);\n    const nonNullType = unwrapped ? null : getNonNullableType(currentSchema);\n    const receiver =\n      unwrapped ?? (nonNullType ? ({ ...currentSchema, type: nonNullType } as JsonSchema) : null);\n    if (receiver) {\n      const fn = getFunctionSchemaForNode({\n        parentSchema: currentSchema,\n        functionName: fullNodeName(nextLink),\n        isCustomFunction: true,\n        platformObjectJsonSchema,\n        primitiveUtilities,\n      });\n      if (fn?.acceptsNullReceiver !== true) {\n        return null;\n      }\n      currentSchema = receiver;\n    }\n  }\n  if (isJsonSchemaRef(currentSchema)) {\n    currentSchema = resolveJssRef(currentSchema, platformObjectJsonSchema);\n  } else if (isJsonSchemaArray(currentSchema) && isJsonSchemaRef(currentSchema.items)) {\n    currentSchema = {\n      ...currentSchema,\n      items: {\n        ...resolveJssRef(currentSchema.items, platformObjectJsonSchema),\n      },\n    };\n  }\n  if (!('type' in currentSchema)) {\n    return null;\n  }\n\n  const schemaId = getPrimitiveSchemaId(currentSchema);\n  if (schemaId && schemaId in primitiveUtilities) {\n    const utilityReturnType = getPrimitiveUtilitiesReturnSchema(\n      currentSchema,\n      nextLink,\n      primitiveUtilities[schemaId],\n    );\n    if (utilityReturnType) {\n      return utilityReturnType;\n    }\n  }\n  if ('properties' in currentSchema) {\n    const propertySchema = currentSchema.properties[fullNodeName(nextLink)];\n    if (propertySchema && isFunctionSchema(propertySchema)) {\n      return propertySchema.properties.returnType;\n    }\n    return propertySchema ?? null;\n  }\n  return null;\n};\n\n/**\n * Returns the FunctionJsonSchema for `functionName` within `parentSchema`, checking both\n * primitive utilities (e.g. array/string methods) and direct object properties.\n * Returns null if not found or not a function schema.\n */\nexport const getFunctionSchemaForNode = ({\n  parentSchema,\n  functionName,\n  isCustomFunction,\n  platformObjectJsonSchema,\n  primitiveUtilities,\n}: {\n  parentSchema: JsonSchema;\n  functionName: string;\n  isCustomFunction: boolean;\n  platformObjectJsonSchema: ObjectSchemaMap;\n  primitiveUtilities: ObjectSchemaMap;\n}): FunctionJsonSchema | null => {\n  if (isCustomFunction) {\n    parentSchema = getNonNullableRefSchema(parentSchema) ?? parentSchema;\n  }\n  if (isJsonSchemaRef(parentSchema)) {\n    parentSchema = resolveJssRef(parentSchema, platformObjectJsonSchema);\n  }\n\n  const schemaId = getPrimitiveSchemaId(parentSchema);\n  if (schemaId && schemaId in primitiveUtilities) {\n    const utilitySchema = primitiveUtilities[schemaId].properties[functionName];\n    if (utilitySchema && isFunctionSchema(utilitySchema)) {\n      return utilitySchema;\n    }\n  }\n\n  if (isJsonSchemaObject(parentSchema) && functionName in parentSchema.properties) {\n    const propSchema = parentSchema.properties[functionName];\n    if (isFunctionSchema(propSchema)) {\n      return propSchema;\n    }\n  }\n\n  return null;\n};\n\n// When the result is an array of platform objects (identified by objectKey on items),\n// inject a $ref so the schema structure matches has_many associations.\n// This ensures consistent operator options in conditionals.\nconst injectRefForPlatformObjectArray = (schema: JsonSchema | null): JsonSchema | null => {\n  if (\n    schema &&\n    isJsonSchemaArray(schema) &&\n    isJsonSchemaObject(schema.items) &&\n    'objectKey' in schema.items &&\n    schema.items.objectKey\n  ) {\n    const schemaId = getSchemaId(schema.items.objectKey, MERGED_SCHEMA_ID);\n    return {\n      ...schema,\n      items: {\n        ...schema.items,\n        $ref: schemaId,\n      },\n    };\n  }\n  return schema;\n};\n\nconst getPrimitiveUtilitiesReturnSchema = (\n  object: JsonSchema,\n  node: MethodChainNode,\n  schema: JsonSchemaObject<JsonSchema | FunctionJsonSchema>,\n): JsonSchema | null => {\n  const name = fullNodeName(node);\n  if (!(name in schema.properties)) {\n    return null;\n  }\n\n  const utilitySchema = schema.properties[name];\n\n  const returnSchema = isFunctionSchema(utilitySchema)\n    ? utilitySchema.properties.returnType\n    : utilitySchema;\n\n  const itemSchema = genericArrayItemSchema(object, returnSchema);\n  if (itemSchema) {\n    return itemSchema;\n  }\n\n  if (isPrecedingSchema(returnSchema)) {\n    return object;\n  }\n\n  if (\n    isConvertedTypeSchema(returnSchema) &&\n    isFunctionNode(node) &&\n    node.params[returnSchema.position] &&\n    isStringNode(node.params[returnSchema.position])\n  ) {\n    const stringNode = node.params[returnSchema.position] as StringNode;\n    return returnSchema.schemaByValue[stringNode.value] ?? EMPTY_JSON_SCHEMA_OBJECT;\n  }\n\n  if (\n    isGenericParameterSchema(returnSchema) &&\n    isFunctionNode(node) &&\n    node.params[returnSchema.position] &&\n    isStringNode(node.params[returnSchema.position])\n  ) {\n    const stringNode = node.params[returnSchema.position] as StringNode;\n    const objectSchema = isJsonSchemaArray(object) ? object.items : object;\n    if (isJsonSchemaObject(objectSchema)) {\n      const path = stringNode.value.split('.');\n      const resultSchema = path.reduce<JsonSchema | null>((schema, key) => {\n        if (schema == null || !isJsonSchemaObject(schema) || !schema.properties[key]) {\n          return null;\n        }\n        return schema.properties[key];\n      }, objectSchema);\n\n      return injectRefForPlatformObjectArray(resultSchema);\n    }\n  }\n\n  return 'genericType' in returnSchema ? EMPTY_JSON_SCHEMA_OBJECT : returnSchema;\n};\n\n/**\n * @param path\n * @param allowedFieldPaths - can be a complete path to a base type field\n * (e.g. 'data.some.string_field'), or a partial path to an object ('data')\n * @param fieldPathsAreStrictMatch - true if we only want to match exact paths in allowedFieldPaths and disallowedFieldPaths\n */\nconst isAllowedPath = (path: string, allowedFieldPaths: string[]) => {\n  return allowedFieldPaths.some((fieldPath) => {\n    const valueIsPartialMatch = fieldPath.startsWith(path);\n    const valueIsNestedProp = path.startsWith(`${fieldPath}.`);\n    return valueIsPartialMatch || valueIsNestedProp;\n  });\n};\n\n/**\n * @param path\n * @param disallowedFieldPaths - can be a complete path to a base type field\n * (e.g. 'data.some.string_field'), or a partial path to an object ('data')\n */\nconst isDisallowedPath = (path: string, disallowedFieldPaths: string[]) => {\n  return disallowedFieldPaths.some((fieldPath) => {\n    const valueIsMatch = fieldPath === path;\n    const valueIsNestedProp = path.startsWith(`${fieldPath}.`);\n    return valueIsMatch || valueIsNestedProp;\n  });\n};\n\nexport const isTypeMatch = ({\n  fieldJsonSchema,\n  types,\n  platformObjectJsonSchema = {},\n  arrayTypes,\n  traversedSchemaIds = new Set(),\n}: {\n  fieldJsonSchema: JsonSchema;\n  types: PossibleType[];\n  platformObjectJsonSchema: ObjectSchemaMap;\n  arrayTypes?: PossibleArrayType[];\n  traversedSchemaIds?: Set<string>;\n}): boolean => {\n  const resolvedSchema = isJsonSchemaRef(fieldJsonSchema)\n    ? resolveJssRef(fieldJsonSchema, platformObjectJsonSchema)\n    : fieldJsonSchema;\n\n  if (resolvedSchema.$id) {\n    if (traversedSchemaIds.has(resolvedSchema.$id)) {\n      // We've already traversed this schema ID, which there were no\n      // valid types found for it, so return false to avoid infinite loops\n      return false;\n    } else {\n      // If we haven't traversed this schema ID yet, add it to the set\n      // This allows us to avoid infinite loops when resolving references\n      // in recursive schemas\n      traversedSchemaIds.add(resolvedSchema.$id);\n    }\n  }\n\n  const fieldJsonSchemaType = getJsonSchemaType(resolvedSchema);\n  switch (fieldJsonSchemaType) {\n    case JsonSchemaAllTypes.Object: {\n      const objectSchema = resolvedSchema as JsonSchemaObject;\n      // For generic JsonSchemaObjectKey such as 'report' or 'verification', we match on subtypes\n      // like 'business-watchlist' as well; otherwise, generics don't show anything\n      const isObjectKeyOfType = (type: JsonSchemaObjectKey) =>\n        objectSchema.objectKey &&\n        types.includes(type) &&\n        objectSchema.objectKey.split('/')[0] === type;\n\n      if (\n        types.includes(JsonSchemaTypes.Object) ||\n        (objectSchema.objectKey && types.includes(objectSchema.objectKey)) ||\n        isObjectKeyOfType('report') ||\n        isObjectKeyOfType('verification')\n      ) {\n        return true;\n      }\n\n      return Object.values(objectSchema.properties || {}).some((propJsonSchema) =>\n        isTypeMatch({\n          fieldJsonSchema: propJsonSchema,\n          types,\n          platformObjectJsonSchema,\n          arrayTypes,\n          traversedSchemaIds: traversedSchemaIds,\n        }),\n      );\n    }\n    case JsonSchemaAllTypes.Array: {\n      const arraySchema = resolvedSchema as JsonSchemaArray;\n      const itemSchema = isJsonSchemaRef(arraySchema.items)\n        ? resolveJssRef(arraySchema.items, platformObjectJsonSchema)\n        : arraySchema.items;\n      return (\n        types.includes(JsonSchemaAllTypes.Array) &&\n        // Don't recurse on array, otherwise we risk matching on objects within the array\n        !!arrayTypes &&\n        arrayTypes.some(\n          (schemaType) =>\n            schemaType === getJsonSchemaType(itemSchema) ||\n            (isJsonSchemaObject(itemSchema) && schemaType === itemSchema.objectKey),\n        )\n      );\n    }\n    case JsonSchemaAllTypes.String:\n    case JsonSchemaAllTypes.Number:\n    case JsonSchemaAllTypes.Boolean:\n    case JsonSchemaAllTypes.Integer:\n    case JsonSchemaAllTypes.Date:\n    case JsonSchemaAllTypes.Datetime:\n    case JsonSchemaAllTypes.Enum:\n    case JsonSchemaAllTypes.MultiEnum:\n    case JsonSchemaAllTypes.GroupedEnum:\n    case JsonSchemaAllTypes.Unknown: {\n      return types.some((schemaType) => schemaType === fieldJsonSchemaType);\n    }\n    default:\n      return false;\n  }\n};\n\nexport interface OptionFilters {\n  allowedArrayTypes?: PossibleArrayType[];\n  allowedFieldPaths?: string[];\n  allowedTypes?: PossibleType[];\n  disallowedFieldPaths?: string[];\n  fieldPathsAreStrictMatch?: boolean;\n  requiredPropertyShape?: string[]; // Array of property names that must exist in the schema\n}\n\nexport const hasRequiredPropertyShape = (\n  schema: JsonSchema,\n  requiredPropertyShape: string[],\n  platformObjectJsonSchema: ObjectSchemaMap = {},\n  checkRecursively: boolean = true,\n): boolean => {\n  if (!requiredPropertyShape?.length) {\n    return true;\n  }\n\n  const resolvedSchema = isJsonSchemaRef(schema)\n    ? resolveJssRef(schema, platformObjectJsonSchema)\n    : schema;\n\n  if (\n    resolvedSchema &&\n    'type' in resolvedSchema &&\n    resolvedSchema.type === JsonSchemaTypes.Object &&\n    'properties' in resolvedSchema &&\n    resolvedSchema.properties\n  ) {\n    const schemaProperties = resolvedSchema.properties as Record<string, JsonSchema>;\n    const hasAllProperties = requiredPropertyShape.every(\n      (propName) => propName in schemaProperties,\n    );\n\n    if (hasAllProperties) {\n      return true;\n    }\n\n    if (checkRecursively) {\n      return Object.values(schemaProperties).some((propSchema) =>\n        hasRequiredPropertyShape(\n          propSchema,\n          requiredPropertyShape,\n          platformObjectJsonSchema,\n          checkRecursively,\n        ),\n      );\n    }\n  }\n  return false;\n};\n\nconst filterForAllowedSchemaOptions = (\n  options: Option[] = [],\n  {\n    allowedArrayTypes,\n    allowedFieldPaths,\n    allowedTypes,\n    disallowedFieldPaths,\n    fieldPathsAreStrictMatch,\n    requiredPropertyShape,\n  }: OptionFilters,\n  platformObjectJsonSchema: ObjectSchemaMap = {},\n) => {\n  let filteredOptions = options;\n\n  if (fieldPathsAreStrictMatch) {\n    if (allowedFieldPaths?.length || disallowedFieldPaths?.length || allowedTypes?.length) {\n      filteredOptions = filteredOptions.filter((option) =>\n        isValidOption(\n          option.schema,\n          allowedFieldPaths ?? [],\n          disallowedFieldPaths ?? [],\n          allowedTypes ?? [],\n          allowedArrayTypes ?? [],\n          option.value.split('.'),\n          platformObjectJsonSchema,\n        ),\n      );\n    }\n  } else {\n    if (allowedFieldPaths?.length) {\n      filteredOptions = filteredOptions.filter((option) =>\n        isAllowedPath(option.value, allowedFieldPaths),\n      );\n    }\n    if (disallowedFieldPaths?.length) {\n      filteredOptions = filteredOptions.filter(\n        (option) => !isDisallowedPath(option.value, disallowedFieldPaths),\n      );\n    }\n    if (allowedTypes?.length) {\n      filteredOptions = filteredOptions.filter((option) =>\n        isTypeMatch({\n          fieldJsonSchema: option.schema,\n          types: allowedTypes,\n          platformObjectJsonSchema,\n          arrayTypes: allowedArrayTypes,\n        }),\n      );\n    }\n  }\n\n  // Add a recursive function to check if schema or any nested schema has the required properties\n  if (requiredPropertyShape?.length) {\n    filteredOptions = filteredOptions.filter((option) =>\n      hasRequiredPropertyShape(option.schema, requiredPropertyShape, platformObjectJsonSchema),\n    );\n  }\n\n  return filteredOptions;\n};\n\nexport const getOptionForValue = ({\n  value,\n  jsonSchema,\n  schemaForFieldPath,\n}: {\n  value: string;\n  jsonSchema: JsonSchema;\n  schemaForFieldPath: (\n    path: string,\n    initialSchema: JsonSchema,\n  ) => { schema: JsonSchema | null; propertyName: string | null };\n}): Option | null => {\n  const { schema, propertyName } = schemaForFieldPath(value, jsonSchema);\n  if (!schema || !propertyName) {\n    return null;\n  }\n\n  const methodChain = parseMethodChainForJSS(value);\n  return {\n    label: methodChain ? methodChainToString(methodChain) : value,\n    value: methodChain ? methodChainToString(methodChain) : value,\n    property: propertyName,\n    schema,\n    methodChain,\n  };\n};\n\nexport const validatePath = ({\n  path,\n  jsonSchema,\n  platformObjectJsonSchema = {},\n  primitiveUtilities = {},\n  optionFilters,\n}: {\n  path: string;\n  jsonSchema: JsonSchema;\n  platformObjectJsonSchema: ObjectSchemaMap;\n  primitiveUtilities: ObjectSchemaMap;\n  optionFilters?: OptionFilters;\n}) => {\n  const schemaOptions = getSchemaOptions({\n    option: { schema: jsonSchema, methodChain: parseMethodChainForJSS('') },\n    optionFilters,\n    platformObjectJsonSchema,\n    primitiveUtilities,\n  });\n  const { methodChain, partial } = parseWithPartialOption(path);\n\n  const matchedSchemaOptions = methodChain.links.reduce<Option[]>((currentSchema, link) => {\n    if (currentSchema.length === 0) {\n      return [];\n    }\n    const optionMatch = currentSchema.find((option) => option.property === link.name);\n    if (optionMatch) {\n      return getSchemaOptions({\n        option: optionMatch,\n        optionFilters,\n        platformObjectJsonSchema,\n        primitiveUtilities,\n      });\n    }\n    return [];\n  }, schemaOptions);\n\n  const optionsWithPartiallyMatchedFinalLink = matchedSchemaOptions.filter((option) =>\n    option.property.includes(partial),\n  );\n  return {\n    valid: optionsWithPartiallyMatchedFinalLink.length > 0,\n    schemaOptions: optionsWithPartiallyMatchedFinalLink,\n    partial,\n  };\n};\n\n/**\n * Given a method chain that corresponds to the passed schema, find the right-most indentifier that\n * is a platform object and split the method chain on that identifier, with the platform object on\n * the left side.\n *\n * This function is used to optimize a method chain into two parts, left side for server resolution\n * and right side for client resolution.\n *\n * For example:\n * current_case.fields.field_a -> ['current_case', 'fields.field_a']\n * current_case.inquiries.first.id -> ['current_case.inquiries.first', 'id']\n * current_case.account.fields.field_b -> ['current_case.account', 'fields.field_b']\n */\nexport const splitAtNearestParentObject = (\n  chain: Chain,\n  currentSchema: JsonSchemaObject,\n  platformSchemaMap: ObjectSchemaMap,\n  primitiveUtilities: ObjectSchemaMap,\n): [leftChain: Chain, rightChain: Chain] => {\n  // Create a list of schemas that match each link in the method chain.\n  // The list is reversed such that the first schema matches the last link of the method chain\n  // for the next step.\n  const leafUpLinkSchemas: (JsonSchema | null)[] = [currentSchema];\n  for (const link of chain.links) {\n    const nextSchema = nextLinkSchema({\n      currentSchema: leafUpLinkSchemas[0],\n      nextLink: link,\n      platformObjectJsonSchema: platformSchemaMap,\n      primitiveUtilities,\n    });\n    leafUpLinkSchemas.unshift(nextSchema);\n  }\n\n  // List of links that correspond to the left and right sides of the split.\n  // As we walk the schema from leaf to root, we move links to the right side.\n  const leafUpLeftLinks = [...chain.links].reverse();\n  const leafUpRightLinks: typeof leafUpLeftLinks = [];\n\n  for (const [i, linkSchema] of leafUpLinkSchemas.entries()) {\n    if (!linkSchema) {\n      // When the schema is unknown, check if the current link is an identifier accessing a\n      // property on an unresolvable platform object ref. If any remaining schema in the\n      // ancestor chain is a $ref (or array of $refs), we're within a platform object whose\n      // schema couldn't be resolved — push the identifier to the client (right) side.\n      if (isIdentifierNode(leafUpLeftLinks[0])) {\n        const nearestPlatformAncestor = leafUpLinkSchemas\n          .slice(i + 1)\n          .find(\n            (s) => s && (isJsonSchemaRef(s) || (isJsonSchemaArray(s) && isJsonSchemaRef(s.items))),\n          );\n        if (nearestPlatformAncestor) {\n          leafUpRightLinks.push(leafUpLeftLinks.shift()!);\n          continue;\n        }\n      }\n      // If we are missing schema, break out asap to keep links on the left.\n      break;\n    } else if ('$id' in linkSchema || isJsonSchemaRef(linkSchema)) {\n      break;\n    } else if (isJsonSchemaArray(linkSchema)) {\n      if ('$id' in linkSchema.items || isJsonSchemaRef(linkSchema.items)) {\n        break;\n      }\n      // Array-returning functions (filter, sort, etc.) on platform object arrays\n      // must be resolved server-side even when the items ref cannot be resolved.\n      if (isFunctionNode(leafUpLeftLinks[0])) {\n        break;\n      }\n    } else if (isFunctionNode(leafUpLeftLinks[0])) {\n      break;\n    } else if (isIdentifierNode(leafUpLeftLinks[0])) {\n      const nextSchema = leafUpLinkSchemas[i + 1];\n      // If the preceding schema has a primitive schema ID in the utilities, the identifier\n      // was resolved via primitive utilities (e.g. 'trim' on a string, 'count' on an array).\n      // The server handles these inline, so keep the whole chain server-side.\n      if (nextSchema) {\n        const primitiveId = getPrimitiveSchemaId(nextSchema);\n        if (primitiveId && primitiveId in primitiveUtilities) {\n          break;\n        }\n      }\n      // Real special case here. If:\n      // - The current link is an identifier\n      // - The next schema is an array\n      // = break out, because we don't want to load the whole array into the client\n      if (nextSchema && isJsonSchemaArray(nextSchema)) {\n        break;\n      }\n    }\n\n    leafUpRightLinks.push(leafUpLeftLinks.shift()!);\n  }\n\n  const leftChain: Chain = {\n    type: MethodChainNodeTypes.Chain,\n    links: leafUpLeftLinks.reverse(),\n  };\n  const rightChain: Chain = {\n    type: MethodChainNodeTypes.Chain,\n    links: leafUpRightLinks.reverse(),\n  };\n  return [leftChain, rightChain];\n};\n"],"mappings":"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"}

package/dist/lib/semanticColor.d.mts

@@ -1,2 +1,2 @@
-import { a as semanticTokens, i as semanticOnly, n as SemanticFallback, r as semanticColor, t as MaybeSemanticTheme } from "../semanticColor-Cru2gSys.mjs";
+import { a as semanticTokens, i as semanticOnly, n as SemanticFallback, r as semanticColor, t as MaybeSemanticTheme } from "../semanticColor-Bg0H3RUL.mjs";
 export { MaybeSemanticTheme, SemanticFallback, semanticColor, semanticOnly, semanticTokens };

package/dist/lib/snakifyPath.d.mts

@@ -0,0 +1,5 @@
+//#region lib/snakifyPath.d.ts
+declare const snakify: (toSnake: string) => string;
+//#endregion
+export { snakify };
+//# sourceMappingURL=snakifyPath.d.mts.map

package/dist/lib/snakifyPath.mjs

@@ -0,0 +1,11 @@
+//#region lib/snakifyPath.ts
+const ISO_8601_PATTERN = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2}|Z)?/;
+const containsISO8601 = (value) => ISO_8601_PATTERN.test(value);
+const snakify = (toSnake) => {
+	if (!toSnake) return toSnake;
+	return toSnake.split(".").map((segment) => containsISO8601(segment) ? segment : segment.replace(/-/g, "_")).join(".");
+};
+//#endregion
+export { snakify };
+
+//# sourceMappingURL=snakifyPath.mjs.map

package/dist/lib/snakifyPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snakifyPath.mjs","names":[],"sources":["../../lib/snakifyPath.ts"],"sourcesContent":["const ISO_8601_PATTERN = /\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:[+-]\\d{2}:\\d{2}|Z)?/;\n\nconst containsISO8601 = (value: string) => ISO_8601_PATTERN.test(value);\n\nexport const snakify = (toSnake: string) => {\n  if (!toSnake) {\n    return toSnake;\n  }\n\n  return toSnake\n    .split('.')\n    .map((segment) => (containsISO8601(segment) ? segment : segment.replace(/-/g, '_')))\n    .join('.');\n};\n"],"mappings":";AAAA,MAAM,mBAAmB;AAEzB,MAAM,mBAAmB,UAAkB,iBAAiB,KAAK,MAAM;AAEvE,MAAa,WAAW,YAAoB;AAC1C,KAAI,CAAC,QACH,QAAO;AAGT,QAAO,QACJ,MAAM,IAAI,CACV,KAAK,YAAa,gBAAgB,QAAQ,GAAG,UAAU,QAAQ,QAAQ,MAAM,IAAI,CAAE,CACnF,KAAK,IAAI"}

package/dist/lib/useChain.d.mts

@@ -0,0 +1,2 @@
+import { n as useChain, r as useChainSchema, t as chainRootsFromSchemaProperties } from "../useChain-CEsXE2Bx.mjs";
+export { chainRootsFromSchemaProperties, useChain as default, useChainSchema };

package/dist/lib/useChain.mjs

@@ -0,0 +1,2 @@
+import { n as useChain, r as useChainSchema, t as chainRootsFromSchemaProperties } from "../useChain-CKqYGdx4.mjs";
+export { chainRootsFromSchemaProperties, useChain as default, useChainSchema };