@persona/design-system 0.5.0 → 0.5.1

package/dist/lib/jsonSchema.mjs

@@ -0,0 +1,260 @@
+import "./fieldSchemaTypes.mjs";
+import { startCase } from "lodash-es";
+//#region lib/jsonSchema.ts
+let JsonSchemaTypes = /* @__PURE__ */ function(JsonSchemaTypes) {
+	JsonSchemaTypes["Array"] = "array";
+	JsonSchemaTypes["Boolean"] = "boolean";
+	JsonSchemaTypes["Integer"] = "integer";
+	JsonSchemaTypes["Number"] = "number";
+	JsonSchemaTypes["Object"] = "object";
+	JsonSchemaTypes["String"] = "string";
+	JsonSchemaTypes["Null"] = "null";
+	return JsonSchemaTypes;
+}({});
+const EMPTY_JSON_SCHEMA_OBJECT = {
+	type: "object",
+	properties: {}
+};
+const isJsonSchemaObject = (schema) => {
+	return "type" in schema && schema.type === "object";
+};
+const isJsonSchemaArray = (schema) => {
+	return "type" in schema && schema.type === "array";
+};
+/** Returns true for non-primitive schemas (object, array, or $ref to a platform object). */
+const isNonPrimitiveSchema = (schema) => isJsonSchemaObject(schema) || isJsonSchemaArray(schema) || isJsonSchemaRef(schema);
+const isFileType = (fieldType) => fieldType === "file";
+const isFileField = (schema) => "fieldType" in schema && isFileType(schema.fieldType);
+const isArrayWithFileItems = (schema) => isJsonSchemaArray(schema) && !!schema.items && typeof schema.items === "object" && "fieldType" in schema.items && isFileType(schema.items.fieldType);
+/** ImageGallery accepts file schemas or arrays of file items. */
+const isFileSchema = (schema) => isFileField(schema) || isArrayWithFileItems(schema);
+const isJsonSchemaRef = (schema) => {
+	return "$ref" in schema;
+};
+const isJsonSchemaPlatformObject = (schema) => {
+	return isJsonSchemaRef(schema) && "objectKey" in schema;
+};
+const isJsonSchemaString = (schema) => {
+	return "type" in schema && schema.type === "string";
+};
+const isJsonSchemaDate = (schema) => {
+	return "type" in schema && schema.type === "string" && "format" in schema && schema.format === "date";
+};
+const isJsonSchemaDateTime = (schema) => {
+	return "type" in schema && schema.type === "string" && "format" in schema && schema.format === "date-time";
+};
+const isJsonSchemaSecret = (schema) => {
+	return "type" in schema && schema.type === "string" && "format" in schema && schema.format === "secret";
+};
+const isOneOfSchema = (schema) => {
+	return "oneOf" in schema && schema.oneOf != null && Array.isArray(schema.oneOf);
+};
+const isOneOfStringSchema = (schema) => {
+	return isJsonSchemaString(schema) && "oneOf" in schema && schema.oneOf != null && Array.isArray(schema.oneOf);
+};
+const isFunctionSchema = (schema) => {
+	return schema && "function" in schema && !!schema.function;
+};
+const genericArrayItemSchema = (object, schema) => {
+	if (!("genericType" in schema) || schema.genericType !== "array_item_schema") return null;
+	const array = withNameableType(object);
+	return array != null && isJsonSchemaArray(array) && isSubschema(array.items) ? array.items : null;
+};
+const isPrecedingSchema = (schema) => {
+	return "genericType" in schema && schema.genericType === "preceding_schema";
+};
+const isGenericParameterSchema = (schema) => {
+	return "genericType" in schema && schema.genericType === "parameter_schema" && "position" in schema;
+};
+const isConvertedTypeSchema = (schema) => {
+	return "genericType" in schema && schema.genericType === "converted_type" && "schemaByValue" in schema;
+};
+const isJsonSchemaChoices = (schema) => {
+	return "type" in schema && schema.type === "string" && "enum" in schema;
+};
+const isJsonSchemaInteger = (schema) => {
+	return "type" in schema && schema.type === "integer";
+};
+const isJsonSchemaNumber = (schema) => {
+	return "type" in schema && schema.type === "number";
+};
+const isJsonSchemaBoolean = (schema) => {
+	return "type" in schema && schema.type === "boolean";
+};
+const functionParametersFromJsonSchema = (functionSchema, currentSchema) => {
+	if (!isFunctionSchema(functionSchema)) return [];
+	const paramTypes = functionSchema.properties.parameterTypes;
+	const orderedParams = [];
+	Object.entries(paramTypes.properties).forEach(([title, paramObject]) => {
+		orderedParams[paramObject.position] = {
+			title,
+			...genericArrayItemSchema(currentSchema, paramObject) ?? paramObject
+		};
+	});
+	return orderedParams;
+};
+const getArrayItemType = (schema) => {
+	if (!isJsonSchemaArray(schema) || !("type" in schema.items) || schema.items.type == null) return null;
+	const itemType = schema.items.type;
+	switch (itemType) {
+		case "boolean":
+		case "integer":
+		case "number":
+		case "object":
+		case "string": return itemType;
+		case "array": return null;
+		default: return null;
+	}
+};
+/**
+* Display labels for field-backed schemas, whose JSON type alone is too coarse to identify them:
+* every file and relation field serializes as `object`, so only `fieldType` distinguishes a document
+* from a selfie from a plain hash. Shared by both the array-item and object branches below so a type
+* can't be labelled two ways depending on whether it is wrapped in an array.
+*
+* Values follow `FIELD_SCHEMA_TYPE_DISPLAY` in `front-end/lib/fields` so the same field reads the same in the
+* field-schema editor and in these pickers. They are duplicated rather than imported because
+* `front-end/lib/fields` imports this module, and `fieldSchemaTypes` is deliberately dependency-free.
+*
+* These are names, so they are intentionally finer-grained than `getDataTypeFromJsonSchema`, which
+* resolves the same schemas to a rendering strategy: it has no relation case (base `Field::Relation`
+* lands on `DataType.Hash`) and folds NFC into `DataType.GovernmentId`. A label wants to be as
+* specific as the schema allows; a DataType wants to be as specific as the renderer supports.
+*
+* The base `Field::Relation` appears when a producer erases the concrete subtype; "Relation" is
+* vague but still truer than the bare JSON type.
+*/
+const FIELD_TYPE_LABELS = {
+	["Field::Relation::Document::Generic"]: "Document",
+	["file"]: "File",
+	["Field::Relation::Document::GovernmentId"]: "Government ID",
+	["Field::Relation::Document::GovernmentIdNfc"]: "Government ID NFC",
+	["hash"]: "Hash",
+	["json"]: "JSON",
+	["Field::Relation"]: "Relation",
+	["Field::Relation::Selfie"]: "Selfie"
+};
+/**
+* Names the field types that are all `type: 'string'` in JSON Schema and are told apart only by a
+* marker, so an item inside an array reads the same as it would on its own. Returns null for a
+* plain string, leaving the caller to fall back to the JSON type.
+*/
+const stringSubtypeLabel = (schema) => {
+	if (!isJsonSchemaString(schema)) return null;
+	if (schema.fieldType === "choices") return "Choices";
+	if (schema.fieldType === "email-address" || schema.format === "email") return "Email Address";
+	if (schema.format === "date-time") return "Datetime";
+	if (schema.format === "date") return "Date";
+	if (schema.format === "secret") return "Secret";
+	return null;
+};
+/**
+* An `items` slot holds a boolean in JSON Schema 2020-12, and anything at all in a hand-written
+* schema, so a label rule can only treat it as a schema once it is an object.
+*/
+const isSubschema = (items) => items != null && typeof items === "object";
+/**
+* Restates a `type` union as the single type it names, so a caller can apply one label rule to a
+* nullable schema and its non-nullable form alike. Returns null when the type names nothing a label
+* can use: no `type` at all, or a union wider than nullable.
+*/
+const withNameableType = (schema) => {
+	if (!("type" in schema)) return null;
+	const type = schema.type;
+	const nameable = typeof type === "string" ? type : getNonNullableType(schema);
+	if (nameable == null) return null;
+	return {
+		...schema,
+		type: nameable
+	};
+};
+const humanizeSchemaType = ({ schema, parentSchema = {} }) => {
+	if ("function" in schema && schema.function) return "Function";
+	const format = (typeName, { asArray = false } = {}) => {
+		return startCase(typeName.split("/")[0]) + (asArray ? "[]" : "");
+	};
+	const formatObjectKey = (objectKey, options = {}) => typeof objectKey === "string" ? format(objectKey, options) : "Unsupported";
+	if ("genericType" in schema && schema.genericType === "array_item_schema") {
+		const parent = withNameableType(parentSchema);
+		if (parent != null && isJsonSchemaArray(parent) && isSubschema(parent.items)) {
+			if ("objectKey" in parent.items && parent.items.objectKey) return formatObjectKey(parent.items.objectKey);
+			if ("type" in parent.items) {
+				const items = withNameableType(parent.items);
+				return items == null ? "Unsupported" : stringSubtypeLabel(items) ?? format(items.type);
+			}
+		}
+	}
+	if (isJsonSchemaRef(schema) && schema.objectKey) return formatObjectKey(schema.objectKey);
+	if (!("type" in schema)) return "";
+	const named = withNameableType(schema);
+	if (named == null) return "Unsupported";
+	if (isJsonSchemaArray(named)) {
+		if (named.fieldType === "multi-choices") return "Multi Choices";
+		if (isSubschema(named.items)) {
+			if ("objectKey" in named.items && named.items.objectKey) return formatObjectKey(named.items.objectKey, { asArray: true });
+			const items = withNameableType(named.items);
+			if (items != null) {
+				if (isJsonSchemaObject(items)) return `${(items.fieldType && FIELD_TYPE_LABELS[items.fieldType]) ?? "Hash"}[]`;
+				const itemLabel = stringSubtypeLabel(items);
+				if (itemLabel) return `${itemLabel}[]`;
+				return format(items.type, { asArray: true });
+			}
+		}
+	}
+	if (isJsonSchemaString(named)) {
+		if ("objectKey" in named && named.objectKey != null) return formatObjectKey(named.objectKey);
+		const label = stringSubtypeLabel(named);
+		if (label) return label;
+	}
+	if (isJsonSchemaObject(named)) {
+		if (named.objectKey) return formatObjectKey(named.objectKey);
+		const label = named.fieldType && FIELD_TYPE_LABELS[named.fieldType];
+		if (label) return label;
+	}
+	return format(named.type);
+};
+const getNonNullableType = (schema) => {
+	if (!schema || !("type" in schema)) return null;
+	const type = schema.type;
+	if (!Array.isArray(type)) return null;
+	if (type.length !== 2 || !type.includes("null")) return null;
+	const nonNullable = type.find((t) => t !== "null");
+	return typeof nonNullable === "string" ? nonNullable : null;
+};
+/**
+* Unwraps an exactly-nullable platform-object union — a `oneOf` of one `$ref`
+* member and one `null` member — to its `$ref` member. Any other shape
+* (arbitrary unions, multiple refs, inline members) returns null so it is
+* never treated as a single receiver type.
+*/
+const getNonNullableRefSchema = (schema) => {
+	if (!schema || !("oneOf" in schema) || !Array.isArray(schema.oneOf)) return null;
+	if ("type" in schema || schema.oneOf.length !== 2) return null;
+	const nullMembers = schema.oneOf.filter((member) => "type" in member && member.type === "null");
+	if (nullMembers.length !== 1) return null;
+	const refMember = schema.oneOf.find((member) => !nullMembers.includes(member));
+	return refMember && isJsonSchemaRef(refMember) ? refMember : null;
+};
+const isSchemaTypeAllowed = (schema, allowedTypes) => {
+	if (!schema) return false;
+	const nonNullable = getNonNullableType(schema);
+	if (nonNullable) return allowedTypes.includes(nonNullable);
+	if ("type" in schema && !Array.isArray(schema.type) && allowedTypes.includes(schema.type)) return true;
+	if ("format" in schema && typeof schema.format === "string") return allowedTypes.includes(schema.format);
+	return false;
+};
+const extendSchema = (schemaMap, schemaToAdd) => {
+	return Object.fromEntries(Object.entries(schemaMap).map(([key, schema]) => {
+		return [key, {
+			...schema,
+			properties: {
+				...schema?.properties,
+				...schemaToAdd[key]
+			}
+		}];
+	}));
+};
+//#endregion
+export { EMPTY_JSON_SCHEMA_OBJECT, JsonSchemaTypes, extendSchema, functionParametersFromJsonSchema, genericArrayItemSchema, getArrayItemType, getNonNullableRefSchema, getNonNullableType, humanizeSchemaType, isArrayWithFileItems, isConvertedTypeSchema, isFileField, isFileSchema, isFileType, isFunctionSchema, isGenericParameterSchema, isJsonSchemaArray, isJsonSchemaBoolean, isJsonSchemaChoices, isJsonSchemaDate, isJsonSchemaDateTime, isJsonSchemaInteger, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPlatformObject, isJsonSchemaRef, isJsonSchemaSecret, isJsonSchemaString, isNonPrimitiveSchema, isOneOfSchema, isOneOfStringSchema, isPrecedingSchema, isSchemaTypeAllowed };
+
+//# sourceMappingURL=jsonSchema.mjs.map

package/dist/lib/jsonSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchema.mjs","names":[],"sources":["../../lib/jsonSchema.ts"],"sourcesContent":["import { startCase } from 'lodash-es';\n\nimport { FieldSchemaType } from './fieldSchemaTypes';\nimport type {\n  FunctionConvertedTypeSchema,\n  FunctionGenericParameterSchema,\n  FunctionJsonSchema,\n  FunctionParameterJsonSchema,\n  FunctionReturnTypeJsonSchema,\n  ObjectSchemaMap,\n} from './objectSchemaTypes';\n/**\n * Consumers with a known set of platform object keys can narrow `objectKey`\n * via declaration merging:\n *\n *   declare module '@persona/design-system/lib/jsonSchema' {\n *     interface JsonSchemaObjectKeyRegistry { objectKey: MyObjectKeyEnum }\n *   }\n */\nexport interface JsonSchemaObjectKeyRegistry {}\n\nexport type JsonSchemaObjectKey = JsonSchemaObjectKeyRegistry extends {\n  objectKey: infer K extends string;\n}\n  ? K\n  : string;\n\nexport enum JsonSchemaTypes {\n  Array = 'array',\n  Boolean = 'boolean',\n  Integer = 'integer',\n  Number = 'number',\n  Object = 'object',\n  String = 'string',\n  Null = 'null',\n}\n\nexport type JsonSchemaBasicTypes =\n  | JsonSchemaTypes.Boolean\n  | JsonSchemaTypes.Integer\n  | JsonSchemaTypes.Number\n  | JsonSchemaTypes.String;\n\nexport interface JsonSchemaBase {\n  title?: string;\n  description?: string;\n  examples?: (string | number)[];\n  oneOf?: JsonSchema[];\n  $ref?: string;\n  $id?: string;\n  id?: string; // custom\n  // TODO: This likely should be a `JsonSchema` not an object containing only `type` but currently\n  // only simple objects with a `type` property are expected.\n  // Setting the correct type causes too-deep type recursion errors elsewhere.\n  serializedSchema?: { type: JsonSchemaTypes } | null; // custom;\n  default?: unknown;\n  readOnly?: boolean;\n}\n\nexport interface JsonSchemaArray<ItemSchema = JsonSchema> extends JsonSchemaBase {\n  type: JsonSchemaTypes.Array;\n  items: ItemSchema;\n  uniqueItems?: boolean;\n  fieldType?: FieldSchemaType.Array | FieldSchemaType.MultiChoices; // custom\n  default?: unknown[];\n  supportedFunctions?: string[];\n}\n\nexport interface JsonSchemaBoolean extends JsonSchemaBase {\n  type: JsonSchemaTypes.Boolean;\n  fieldType?: FieldSchemaType.Boolean; // custom\n  default?: boolean;\n}\n\nexport interface JsonSchemaInteger extends JsonSchemaBase {\n  type: JsonSchemaTypes.Integer;\n  enum?: number[];\n  minimum?: number;\n  maximum?: number;\n  fieldType?: FieldSchemaType.Integer; // custom\n  default?: number;\n}\n\nexport interface JsonSchemaNumber extends JsonSchemaBase {\n  type: JsonSchemaTypes.Number;\n  enum?: number[];\n  minimum?: number;\n  maximum?: number;\n  fieldType?: FieldSchemaType.Number; // custom\n  default?: number;\n}\n\nexport interface JsonSchemaNull extends JsonSchemaBase {\n  type: JsonSchemaTypes.Null;\n  default?: null;\n}\n\nexport interface JsonSchemaObject<PropertySchema = JsonSchema> extends JsonSchemaBase {\n  type: JsonSchemaTypes.Object;\n  properties: Record<string, PropertySchema>;\n  required?: string[];\n  // custom\n  objectKey?: JsonSchemaObjectKey;\n  // custom\n  fieldType?:\n    | FieldSchemaType.File\n    | FieldSchemaType.Hash\n    | FieldSchemaType.Json\n    | FieldSchemaType.Relation\n    | FieldSchemaType.DocumentGeneric\n    | FieldSchemaType.GovernmentId\n    | FieldSchemaType.GovernmentIdNfc\n    | FieldSchemaType.Selfie;\n  // custom\n  isVariable?: boolean;\n  // custom: picker subtitle for a chain root; generated root `description`s\n  // otherwise just repeat the label and are hidden\n  rootDescription?: string;\n  additionalProperties?: boolean;\n  baseSupportedFunctions?: string[];\n}\n\nexport const EMPTY_JSON_SCHEMA_OBJECT: JsonSchemaObject = {\n  type: JsonSchemaTypes.Object,\n  properties: {},\n};\n\nexport interface JsonSchemaString extends JsonSchemaBase {\n  type: JsonSchemaTypes.String;\n  enum?: string[];\n  oneOf?: JsonSchemaConst[];\n  const?: string;\n  format?: string;\n  group?: string; // custom\n  labels?: string[]; // custom\n  maxLength?: number | null;\n  fieldType?:\n    | FieldSchemaType.Choices\n    | FieldSchemaType.Date\n    | FieldSchemaType.Datetime\n    | FieldSchemaType.EmailAddress\n    | FieldSchemaType.String; // custom\n  default?: string;\n}\n\nexport interface JsonSchemaAnyOf extends JsonSchemaBase {\n  anyOf: JsonSchema[];\n}\n\nexport interface JsonSchemaConst extends JsonSchemaBase {\n  const: string;\n}\n\nexport interface JsonSchemaRef extends JsonSchemaBase {\n  $ref: string;\n  // custom\n  objectKey?: JsonSchemaObjectKey;\n}\n\nexport type JsonSchemaEmpty = Record<string, never>;\n\nexport type JsonSchemaBasic =\n  | JsonSchemaBoolean\n  | JsonSchemaInteger\n  | JsonSchemaNumber\n  | JsonSchemaString;\n\n// This is an explicit type for json schemas that only use the standard types.\n// e.g. All subschemas will have a `type` attribute.\n// This is useful for when you know you won't be dealing with any uncommon schemas like anyOf.\nexport type JsonSchemaCore =\n  | JsonSchemaArray<JsonSchemaCore>\n  | JsonSchemaBoolean\n  | JsonSchemaInteger\n  | JsonSchemaNumber\n  | JsonSchemaObject<JsonSchemaCore>\n  | JsonSchemaString;\n\nexport type JsonSchema =\n  | JsonSchemaArray\n  | JsonSchemaBoolean\n  | JsonSchemaInteger\n  | JsonSchemaNumber\n  | JsonSchemaObject\n  | JsonSchemaString\n  | JsonSchemaAnyOf\n  | JsonSchemaConst\n  | JsonSchemaRef\n  | JsonSchemaBase;\n\nexport const isJsonSchemaObject = (schema: JsonSchema): schema is JsonSchemaObject => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.Object;\n};\n\nexport const isJsonSchemaArray = (schema: JsonSchema): schema is JsonSchemaArray => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.Array;\n};\n\n/** Returns true for non-primitive schemas (object, array, or $ref to a platform object). */\nexport const isNonPrimitiveSchema = (schema: JsonSchema): boolean =>\n  isJsonSchemaObject(schema) || isJsonSchemaArray(schema) || isJsonSchemaRef(schema);\n\nexport const isFileType = (\n  fieldType: FieldSchemaType | undefined,\n): fieldType is FieldSchemaType.File => fieldType === FieldSchemaType.File;\n\nexport const isFileField = (schema: JsonSchema): boolean =>\n  'fieldType' in schema && isFileType(schema.fieldType);\n\nexport const isArrayWithFileItems = (schema: JsonSchema): boolean =>\n  isJsonSchemaArray(schema) &&\n  !!schema.items &&\n  typeof schema.items === 'object' &&\n  'fieldType' in schema.items &&\n  isFileType(schema.items.fieldType);\n\n/** ImageGallery accepts file schemas or arrays of file items. */\nexport const isFileSchema = (schema: JsonSchema): boolean =>\n  isFileField(schema) || isArrayWithFileItems(schema);\n\nexport const isJsonSchemaRef = (schema: JsonSchema): schema is JsonSchemaRef => {\n  return '$ref' in schema;\n};\n\nexport const isJsonSchemaPlatformObject = (schema: JsonSchema): schema is JsonSchemaRef => {\n  return isJsonSchemaRef(schema) && 'objectKey' in schema;\n};\n\nexport const isJsonSchemaString = (schema: JsonSchema): schema is JsonSchemaString => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.String;\n};\n\nexport const isJsonSchemaDate = (schema: JsonSchema): schema is JsonSchemaString => {\n  return (\n    'type' in schema &&\n    schema.type === JsonSchemaTypes.String &&\n    'format' in schema &&\n    schema.format === 'date'\n  );\n};\n\nexport const isJsonSchemaDateTime = (schema: JsonSchema): schema is JsonSchemaString => {\n  return (\n    'type' in schema &&\n    schema.type === JsonSchemaTypes.String &&\n    'format' in schema &&\n    schema.format === 'date-time'\n  );\n};\n\nexport const isJsonSchemaSecret = (schema: JsonSchema): schema is JsonSchemaString => {\n  return (\n    'type' in schema &&\n    schema.type === JsonSchemaTypes.String &&\n    'format' in schema &&\n    schema.format === 'secret'\n  );\n};\n\nexport const isOneOfSchema = (\n  schema: JsonSchema,\n): schema is JsonSchemaBase & { oneOf: JsonSchemaConst[] } => {\n  return 'oneOf' in schema && schema.oneOf != null && Array.isArray(schema.oneOf);\n};\n\nexport const isOneOfStringSchema = (\n  schema: JsonSchema,\n): schema is JsonSchemaString & { oneOf: JsonSchemaConst[] } => {\n  return (\n    isJsonSchemaString(schema) &&\n    'oneOf' in schema &&\n    schema.oneOf != null &&\n    Array.isArray(schema.oneOf)\n  );\n};\n\nexport const isFunctionSchema = (schema: JsonSchema): schema is FunctionJsonSchema => {\n  return schema && 'function' in schema && !!schema.function;\n};\n\nexport const genericArrayItemSchema = (\n  object: JsonSchema,\n  schema: FunctionParameterJsonSchema | FunctionReturnTypeJsonSchema,\n): JsonSchema | null => {\n  if (!('genericType' in schema) || schema.genericType !== 'array_item_schema') {\n    return null;\n  }\n  const array = withNameableType(object);\n  return array != null && isJsonSchemaArray(array) && isSubschema(array.items) ? array.items : null;\n};\n\nexport const isPrecedingSchema = (\n  schema: FunctionParameterJsonSchema | FunctionReturnTypeJsonSchema,\n) => {\n  return 'genericType' in schema && schema.genericType === 'preceding_schema';\n};\n\nexport const isGenericParameterSchema = (\n  schema: FunctionParameterJsonSchema | FunctionReturnTypeJsonSchema,\n): schema is FunctionGenericParameterSchema => {\n  return (\n    'genericType' in schema && schema.genericType === 'parameter_schema' && 'position' in schema\n  );\n};\n\nexport const isConvertedTypeSchema = (\n  schema: FunctionParameterJsonSchema | FunctionReturnTypeJsonSchema,\n): schema is FunctionConvertedTypeSchema => {\n  return (\n    'genericType' in schema && schema.genericType === 'converted_type' && 'schemaByValue' in schema\n  );\n};\n\nexport const isJsonSchemaChoices = (schema: JsonSchema): schema is JsonSchemaString => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.String && 'enum' in schema;\n};\n\nexport const isJsonSchemaInteger = (schema: JsonSchema): schema is JsonSchemaInteger => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.Integer;\n};\n\nexport const isJsonSchemaNumber = (schema: JsonSchema): schema is JsonSchemaNumber => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.Number;\n};\n\nexport const isJsonSchemaBoolean = (schema: JsonSchema): schema is JsonSchemaBoolean => {\n  return 'type' in schema && schema.type === JsonSchemaTypes.Boolean;\n};\n\nexport const functionParametersFromJsonSchema = (\n  functionSchema: JsonSchema,\n  currentSchema: JsonSchema,\n): JsonSchema[] => {\n  if (!isFunctionSchema(functionSchema)) {\n    return [];\n  }\n\n  const paramTypes = functionSchema.properties.parameterTypes;\n  const orderedParams: JsonSchema[] = [];\n  Object.entries(paramTypes.properties).forEach(([title, paramObject]) => {\n    orderedParams[paramObject.position] = {\n      title,\n      ...(genericArrayItemSchema(currentSchema, paramObject) ?? paramObject),\n    };\n  });\n  return orderedParams;\n};\n\nexport const getArrayItemType = (schema: JsonSchema): JsonSchemaTypes | null => {\n  if (!isJsonSchemaArray(schema) || !('type' in schema.items) || schema.items.type == null) {\n    return null;\n  }\n\n  const itemType = schema.items.type;\n\n  switch (itemType) {\n    case JsonSchemaTypes.Boolean:\n    case JsonSchemaTypes.Integer:\n    case JsonSchemaTypes.Number:\n    case JsonSchemaTypes.Object:\n    case JsonSchemaTypes.String:\n      return itemType;\n    case JsonSchemaTypes.Array:\n      // Nested arrays are not supported for simple array item types\n      return null;\n    default:\n      return null;\n  }\n};\n\n/**\n * Display labels for field-backed schemas, whose JSON type alone is too coarse to identify them:\n * every file and relation field serializes as `object`, so only `fieldType` distinguishes a document\n * from a selfie from a plain hash. Shared by both the array-item and object branches below so a type\n * can't be labelled two ways depending on whether it is wrapped in an array.\n *\n * Values follow `FIELD_SCHEMA_TYPE_DISPLAY` in `front-end/lib/fields` so the same field reads the same in the\n * field-schema editor and in these pickers. They are duplicated rather than imported because\n * `front-end/lib/fields` imports this module, and `fieldSchemaTypes` is deliberately dependency-free.\n *\n * These are names, so they are intentionally finer-grained than `getDataTypeFromJsonSchema`, which\n * resolves the same schemas to a rendering strategy: it has no relation case (base `Field::Relation`\n * lands on `DataType.Hash`) and folds NFC into `DataType.GovernmentId`. A label wants to be as\n * specific as the schema allows; a DataType wants to be as specific as the renderer supports.\n *\n * The base `Field::Relation` appears when a producer erases the concrete subtype; \"Relation\" is\n * vague but still truer than the bare JSON type.\n */\nconst FIELD_TYPE_LABELS: Partial<Record<FieldSchemaType, string>> = {\n  [FieldSchemaType.DocumentGeneric]: 'Document',\n  [FieldSchemaType.File]: 'File',\n  [FieldSchemaType.GovernmentId]: 'Government ID',\n  [FieldSchemaType.GovernmentIdNfc]: 'Government ID NFC',\n  [FieldSchemaType.Hash]: 'Hash',\n  [FieldSchemaType.Json]: 'JSON',\n  [FieldSchemaType.Relation]: 'Relation',\n  [FieldSchemaType.Selfie]: 'Selfie',\n};\n\n/**\n * Names the field types that are all `type: 'string'` in JSON Schema and are told apart only by a\n * marker, so an item inside an array reads the same as it would on its own. Returns null for a\n * plain string, leaving the caller to fall back to the JSON type.\n */\nconst stringSubtypeLabel = (schema: JsonSchema): string | null => {\n  if (!isJsonSchemaString(schema)) {\n    return null;\n  }\n  if (schema.fieldType === FieldSchemaType.Choices) {\n    return 'Choices';\n  }\n  // The backend platform-object schema sends both markers for an email address; a schema built\n  // from a field schema on the client sends `format` alone.\n  if (schema.fieldType === FieldSchemaType.EmailAddress || schema.format === 'email') {\n    return 'Email Address';\n  }\n  if (schema.format === 'date-time') {\n    return 'Datetime';\n  }\n  if (schema.format === 'date') {\n    return 'Date';\n  }\n  if (schema.format === 'secret') {\n    return 'Secret';\n  }\n  return null;\n};\n\n/**\n * An `items` slot holds a boolean in JSON Schema 2020-12, and anything at all in a hand-written\n * schema, so a label rule can only treat it as a schema once it is an object.\n */\nconst isSubschema = (items: unknown): items is JsonSchema =>\n  items != null && typeof items === 'object';\n\n/**\n * Restates a `type` union as the single type it names, so a caller can apply one label rule to a\n * nullable schema and its non-nullable form alike. Returns null when the type names nothing a label\n * can use: no `type` at all, or a union wider than nullable.\n */\nconst withNameableType = (\n  schema: JsonSchema | FunctionJsonSchema,\n): (JsonSchema & { type: JsonSchemaTypes }) | null => {\n  if (!('type' in schema)) {\n    return null;\n  }\n  const type = schema.type as JsonSchemaTypes | JsonSchemaTypes[];\n  const nameable = typeof type === 'string' ? type : getNonNullableType(schema);\n  if (nameable == null) {\n    return null;\n  }\n  const named = { ...schema, type: nameable };\n  return named as JsonSchema & { type: JsonSchemaTypes };\n};\n\nexport const humanizeSchemaType = ({\n  schema,\n  parentSchema = {},\n}: {\n  schema: JsonSchema | FunctionJsonSchema;\n  parentSchema?: JsonSchema;\n}): string => {\n  if ('function' in schema && schema.function) {\n    return 'Function';\n  }\n\n  const format = (typeName: string, { asArray = false }: { asArray?: boolean } = {}): string => {\n    return startCase(typeName.split('/')[0]) + (asArray ? '[]' : '');\n  };\n\n  // Unlike a `type`, an `objectKey` is never narrowed before it gets here, and a customer-authored\n  // schema can hold anything in it.\n  const formatObjectKey = (objectKey: unknown, options: { asArray?: boolean } = {}): string =>\n    typeof objectKey === 'string' ? format(objectKey, options) : 'Unsupported';\n\n  if ('genericType' in schema && schema.genericType === 'array_item_schema') {\n    const parent = withNameableType(parentSchema);\n\n    if (parent != null && isJsonSchemaArray(parent) && isSubschema(parent.items)) {\n      if ('objectKey' in parent.items && parent.items.objectKey) {\n        return formatObjectKey(parent.items.objectKey);\n      }\n\n      if ('type' in parent.items) {\n        // The option here is the item itself, so an item type that names nothing leaves no outer\n        // type to fall back on.\n        const items = withNameableType(parent.items);\n        return items == null ? 'Unsupported' : (stringSubtypeLabel(items) ?? format(items.type));\n      }\n    }\n  }\n\n  if (isJsonSchemaRef(schema) && schema.objectKey) {\n    return formatObjectKey(schema.objectKey);\n  }\n\n  if (!('type' in schema)) {\n    return '';\n  }\n\n  // Resolved before any rule reads the type, so a nullable schema is labelled the same way whether\n  // it stands alone or sits in an array.\n  const named = withNameableType(schema);\n  if (named == null) {\n    // TODO(PLO-345): return one label per non-null type for multi-non-null schemas.\n    return 'Unsupported';\n  }\n\n  if (isJsonSchemaArray(named)) {\n    if (named.fieldType === FieldSchemaType.MultiChoices) {\n      return 'Multi Choices';\n    }\n\n    if (isSubschema(named.items)) {\n      if ('objectKey' in named.items && named.items.objectKey) {\n        return formatObjectKey(named.items.objectKey, { asArray: true });\n      }\n\n      // An item schema with no nameable type leaves the array reading as its own `Array` type,\n      // which is still true of the value.\n      const items = withNameableType(named.items);\n      if (items != null) {\n        // Object items are named by their `fieldType`; ones without a recognized marker read as\n        // `Hash[]` rather than `Object[]`, since a bare `object` says nothing useful to a reader.\n        if (isJsonSchemaObject(items)) {\n          const itemLabel = items.fieldType && FIELD_TYPE_LABELS[items.fieldType];\n          return `${itemLabel ?? 'Hash'}[]`;\n        }\n\n        const itemLabel = stringSubtypeLabel(items);\n        if (itemLabel) {\n          return `${itemLabel}[]`;\n        }\n\n        return format(items.type, { asArray: true });\n      }\n    }\n  }\n\n  if (isJsonSchemaString(named)) {\n    if ('objectKey' in named && named.objectKey != null) {\n      return formatObjectKey(named.objectKey);\n    }\n    const label = stringSubtypeLabel(named);\n    if (label) {\n      return label;\n    }\n  }\n\n  if (isJsonSchemaObject(named)) {\n    if (named.objectKey) {\n      return formatObjectKey(named.objectKey);\n    }\n\n    // An untagged object has no field type to name it, so it falls through to its JSON type.\n    const label = named.fieldType && FIELD_TYPE_LABELS[named.fieldType];\n    if (label) {\n      return label;\n    }\n  }\n\n  return format(named.type);\n};\n\nexport const getNonNullableType = (\n  schema: JsonSchema | FunctionJsonSchema | null | undefined,\n): JsonSchemaTypes | null => {\n  if (!schema || !('type' in schema)) {\n    return null;\n  }\n  const type = schema.type as JsonSchemaTypes | JsonSchemaTypes[];\n  if (!Array.isArray(type)) {\n    return null;\n  }\n  if (type.length !== 2 || !type.includes(JsonSchemaTypes.Null)) {\n    return null;\n  }\n  // Only the cast above makes a member a `JsonSchemaTypes`; a hand-written schema can put anything\n  // in the union, and callers splat this into a `type` their own callers then read as a name.\n  const nonNullable = type.find((t) => t !== JsonSchemaTypes.Null);\n  return typeof nonNullable === 'string' ? nonNullable : null;\n};\n\n/**\n * Unwraps an exactly-nullable platform-object union — a `oneOf` of one `$ref`\n * member and one `null` member — to its `$ref` member. Any other shape\n * (arbitrary unions, multiple refs, inline members) returns null so it is\n * never treated as a single receiver type.\n */\nexport const getNonNullableRefSchema = (\n  schema: JsonSchema | null | undefined,\n): JsonSchemaRef | null => {\n  if (!schema || !('oneOf' in schema) || !Array.isArray(schema.oneOf)) {\n    return null;\n  }\n  if ('type' in schema || schema.oneOf.length !== 2) {\n    return null;\n  }\n  const nullMembers: JsonSchema[] = schema.oneOf.filter(\n    (member) => 'type' in member && (member.type as JsonSchemaTypes) === JsonSchemaTypes.Null,\n  );\n  if (nullMembers.length !== 1) {\n    return null;\n  }\n  const refMember = schema.oneOf.find((member) => !nullMembers.includes(member));\n  return refMember && isJsonSchemaRef(refMember) ? refMember : null;\n};\n\nexport const isSchemaTypeAllowed = (\n  schema: JsonSchema | FunctionJsonSchema | null | undefined,\n  allowedTypes: readonly string[],\n): boolean => {\n  if (!schema) {\n    return false;\n  }\n  const nonNullable = getNonNullableType(schema);\n  if (nonNullable) {\n    return allowedTypes.includes(nonNullable);\n  }\n  if ('type' in schema && !Array.isArray(schema.type) && allowedTypes.includes(schema.type)) {\n    return true;\n  }\n  if ('format' in schema && typeof schema.format === 'string') {\n    return allowedTypes.includes(schema.format);\n  }\n  return false;\n};\n\nexport const extendSchema = (\n  schemaMap: ObjectSchemaMap,\n  schemaToAdd: Partial<Record<keyof typeof schemaMap, Record<string, JsonSchema>>>,\n): ObjectSchemaMap => {\n  return Object.fromEntries(\n    Object.entries(schemaMap).map(([key, schema]) => {\n      return [\n        key,\n        {\n          ...schema,\n          properties: {\n            ...schema?.properties,\n            ...schemaToAdd[key],\n          },\n        },\n      ];\n    }),\n  );\n};\n"],"mappings":"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"}

package/dist/lib/message.d.mts

@@ -1,2 +1,2 @@
-import { t as MessageType } from "../message-CyxgAWZl.mjs";
+import { t as MessageType } from "../message-DfEpU8lV.mjs";
 export { MessageType };

package/dist/lib/methodChain.d.mts

@@ -0,0 +1,66 @@
+import { ASTNodeType } from "../components/SmartTextInput/parser/method-chain/types.mjs";
+import { n as JsonSchema } from "../jsonSchema-B1VonQij.mjs";
+import { ArrayNode, Chain, CustomFunctionNode, FunctionNode, FunctionParamType, IdentifierNode, MethodChainNode, NumberNode, StringNode } from "./methodChainTypes.mjs";
+
+//#region components/SmartTextInput/parser/method-chain/parser.d.ts
+declare class SyntaxError extends Error {
+  expected: string[];
+  found: string;
+  location: {
+    start: number;
+    end: number;
+  };
+}
+//#endregion
+//#region lib/methodChain.d.ts
+declare const methodChainCache: {
+  [key: string]: Chain;
+};
+declare const MethodChainNodeTypes: {
+  readonly Chain: ASTNodeType.Chain;
+  readonly String: ASTNodeType.String;
+  readonly Number: ASTNodeType.Number;
+  readonly Identifier: ASTNodeType.Identifier;
+  readonly Function: ASTNodeType.Function;
+  readonly CustomFunction: ASTNodeType.CustomFunction;
+  readonly Array: ASTNodeType.Array;
+};
+declare const EMPTY_METHOD_CHAIN: Chain;
+type MethodChainLiteral = string | number | (string | number)[];
+declare const isFunctionNode: (node: MethodChainNode) => node is FunctionNode;
+declare const isCustomFunctionNode: (node: MethodChainNode) => node is CustomFunctionNode;
+declare const isIdentifierNode: (node: MethodChainNode) => node is IdentifierNode;
+declare const isStringNode: (node: FunctionParamType) => node is StringNode;
+declare const isArrayNode: (node: FunctionParamType) => node is ArrayNode;
+declare const containsFunctionNode: (methodChain: Chain, ...functionNames: string[]) => boolean;
+/**
+ * Returns true if the string contains any function node (e.g. `.at(...)`) when parsed
+ * as a method chain. Use this to detect whether a field path must be treated as an
+ * opaque key rather than split on `.` for Lodash set/get operations.
+ */
+declare const pathContainsFunctionNode: (path: string) => boolean;
+declare const isEmpty: (methodChain: Chain) => boolean;
+declare const getFunctionParams: (methodChain: Chain, ...functionNames: string[]) => Record<string, MethodChainLiteral[]>;
+declare const removeFunctionNode: (methodChain: Chain, functionName: string) => Chain;
+declare const isValid: (methodChain: string) => boolean;
+/**
+ * The parsed chain, or undefined when it will not parse. Callers that read a chain while it is being
+ * authored hold half-typed input, where a throw is noise rather than an error.
+ */
+declare const tryParseMethodChain: (methodChain: string) => Chain | undefined;
+/** The object a chain is rooted at: `current_case.inquiries` -> `current_case`. */
+declare const methodChainRootName: (methodChain: string) => string | undefined;
+declare const parseMethodChain: (methodChain: string) => Chain;
+declare const methodChainToString: (methodChain: Chain | StringNode | NumberNode | ArrayNode) => string;
+declare const appendedMethodChain: (parentChain: Chain, appended: string | MethodChainNode) => Chain;
+declare const parseWithPartialOption: (path: string) => {
+  methodChain: Chain;
+  partial: string;
+  valid: boolean;
+};
+declare const pathIsNormative: (path: string) => boolean;
+declare const getSyntaxError: () => typeof SyntaxError;
+declare const methodChainNodeToJsonSchema: (node: StringNode | NumberNode | ArrayNode) => JsonSchema | null;
+//#endregion
+export { ArrayNode, Chain, CustomFunctionNode, EMPTY_METHOD_CHAIN, FunctionNode, FunctionParamType, IdentifierNode, MethodChainNode, MethodChainNodeTypes, NumberNode, StringNode, appendedMethodChain, containsFunctionNode, getFunctionParams, getSyntaxError, isArrayNode, isCustomFunctionNode, isEmpty, isFunctionNode, isIdentifierNode, isStringNode, isValid, methodChainCache, methodChainNodeToJsonSchema, methodChainRootName, methodChainToString, parseMethodChain, parseWithPartialOption, pathContainsFunctionNode, pathIsNormative, removeFunctionNode, tryParseMethodChain };
+//# sourceMappingURL=methodChain.d.mts.map

package/dist/lib/methodChain.mjs

@@ -0,0 +1,239 @@
+import { i as peg$parse, n as peg$SyntaxError } from "../parser-Kxos6siN.mjs";
+import { reportError } from "./errorReporter.mjs";
+import "./jsonSchema.mjs";
+import "../components/SmartTextInput/parser/method-chain/types.mjs";
+import { normalizeChain } from "./methodChainNormalize.mjs";
+import { last } from "lodash-es";
+//#region lib/methodChain.ts
+function assertNever(value) {
+	const dump = typeof value === "object" ? JSON.stringify(value) : value;
+	reportError(/* @__PURE__ */ new TypeError(`assertNever non-exhaustive match: ${dump}`));
+}
+const methodChainCache = {};
+const MethodChainNodeTypes = {
+	Chain: "chain",
+	String: "string",
+	Number: "number",
+	Identifier: "identifier",
+	Function: "function",
+	CustomFunction: "custom_function",
+	Array: "array"
+};
+const EMPTY_METHOD_CHAIN = {
+	type: MethodChainNodeTypes.Chain,
+	links: []
+};
+const isFunctionNode = (node) => node.type === MethodChainNodeTypes.Function;
+const isCustomFunctionNode = (node) => node.type === MethodChainNodeTypes.CustomFunction;
+const isIdentifierNode = (node) => node.type === MethodChainNodeTypes.Identifier;
+const isStringNode = (node) => node.type === MethodChainNodeTypes.String;
+const isArrayNode = (node) => node.type === MethodChainNodeTypes.Array;
+const containsFunctionNode = (methodChain, ...functionNames) => methodChain.links.some((link) => isFunctionNode(link) && functionNames.includes(link.name));
+/**
+* Returns true if the string contains any function node (e.g. `.at(...)`) when parsed
+* as a method chain. Use this to detect whether a field path must be treated as an
+* opaque key rather than split on `.` for Lodash set/get operations.
+*/
+const pathContainsFunctionNode = (path) => {
+	try {
+		return parseMethodChain(path).links.some((link) => link.type === MethodChainNodeTypes.Function || link.type === MethodChainNodeTypes.CustomFunction);
+	} catch {
+		return false;
+	}
+};
+const isEmpty = (methodChain) => methodChain.links.length === 0;
+const getFunctionParams = (methodChain, ...functionNames) => {
+	return Object.fromEntries(methodChain.links.filter((link) => isFunctionNode(link)).filter((link) => functionNames.includes(link.name)).map((link) => [link.name, flattenParamsToString(link.params)]));
+};
+const removeFunctionNode = (methodChain, functionName) => {
+	return {
+		type: MethodChainNodeTypes.Chain,
+		links: methodChain.links.filter((link) => link.type !== MethodChainNodeTypes.Function || link.name !== functionName)
+	};
+};
+const flattenParamsToString = (params) => {
+	const result = [];
+	for (const param of params) switch (param.type) {
+		case MethodChainNodeTypes.Chain:
+			result.push(...flattenChainToString(param));
+			break;
+		case MethodChainNodeTypes.String:
+		case MethodChainNodeTypes.Number:
+			result.push(param.value);
+			break;
+		case MethodChainNodeTypes.Array:
+			result.push(param.items.map((item) => item.value));
+			break;
+	}
+	return result;
+};
+const flattenChainToString = (methodChain) => methodChain.links.map((link) => {
+	switch (link.type) {
+		case MethodChainNodeTypes.Function:
+		case MethodChainNodeTypes.CustomFunction: return flattenParamsToString(link.params);
+		case MethodChainNodeTypes.Identifier: return link.name;
+	}
+}).flat();
+const isValid = (methodChain) => {
+	try {
+		parseMethodChain(methodChain);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* The parsed chain, or undefined when it will not parse. Callers that read a chain while it is being
+* authored hold half-typed input, where a throw is noise rather than an error.
+*/
+const tryParseMethodChain = (methodChain) => {
+	try {
+		return parseMethodChain(methodChain);
+	} catch {
+		return;
+	}
+};
+/** The object a chain is rooted at: `current_case.inquiries` -> `current_case`. */
+const methodChainRootName = (methodChain) => {
+	const [root] = tryParseMethodChain(methodChain)?.links ?? [];
+	return root && isIdentifierNode(root) ? root.name : void 0;
+};
+const parseMethodChain = (methodChain) => {
+	if (!methodChain || methodChain === "") return EMPTY_METHOD_CHAIN;
+	if (!methodChainCache[methodChain]) methodChainCache[methodChain] = normalizeChain(peg$parse(methodChain, { strict: true }));
+	return methodChainCache[methodChain];
+};
+const memberToString = (value) => {
+	return `'${value.replace(/'/g, "\\'")}'`;
+};
+const expandExponentialNotation = (str) => {
+	const match = /^(-?)(\d)(?:\.(\d+))?e([+-]\d+)$/.exec(str);
+	if (!match) return str;
+	const [, sign, leadingDigit, fractionDigits = "", exponentStr] = match;
+	const digits = leadingDigit + fractionDigits;
+	const exponent = Number(exponentStr);
+	if (exponent < 0) return `${sign}0.${"0".repeat(-exponent - 1)}${digits}`;
+	return `${sign}${digits}${"0".repeat(exponent - fractionDigits.length)}`;
+};
+const numberLiteralToString = (value) => {
+	if (!Number.isFinite(value)) return `${value}`;
+	const str = value.toString();
+	return /e/i.test(str) ? expandExponentialNotation(str) : str;
+};
+const methodChainToString = (methodChain) => {
+	switch (methodChain.type) {
+		case MethodChainNodeTypes.String: return methodChain.value;
+		case MethodChainNodeTypes.Number: return numberLiteralToString(methodChain.value);
+		case MethodChainNodeTypes.Array: return `[${methodChain.items.map((item) => item.type === MethodChainNodeTypes.String ? memberToString(item.value) : `#${numberLiteralToString(item.value)}`).join(", ")}]`;
+		default: {
+			const regex = /* @__PURE__ */ new RegExp("^@?[a-zA-Z0-9_-]+$");
+			return methodChain.links.map((link, index) => {
+				switch (link.type) {
+					case MethodChainNodeTypes.Identifier: {
+						const fullName = `${link.prefix ?? ""}${link.name}`;
+						return index === 0 ? fullName : regex.test(fullName) ? `.${fullName}` : `['${fullName.replace(/'/g, "\\'")}']`;
+					}
+					case MethodChainNodeTypes.Function: return `.${link.name}(${link.params.map((param) => {
+						switch (param.type) {
+							case MethodChainNodeTypes.String: return memberToString(param.value);
+							case MethodChainNodeTypes.Number: return `#${numberLiteralToString(param.value)}`;
+							case MethodChainNodeTypes.Chain:
+							case MethodChainNodeTypes.Array: return methodChainToString(param);
+						}
+					}).join(", ")})`;
+					case MethodChainNodeTypes.CustomFunction: {
+						const paramStr = link.params.map((param) => {
+							switch (param.type) {
+								case MethodChainNodeTypes.String: return memberToString(param.value);
+								case MethodChainNodeTypes.Number: return `#${numberLiteralToString(param.value)}`;
+								case MethodChainNodeTypes.Chain:
+								case MethodChainNodeTypes.Array: return methodChainToString(param);
+							}
+						}).join(", ");
+						return [
+							index === 0 ? "" : ".",
+							`@${link.name}`,
+							link.params.length === 0 ? "" : `(${paramStr})`
+						].join("");
+					}
+					default: assertNever(link);
+				}
+			}).join("");
+		}
+	}
+};
+const appendedMethodChain = (parentChain, appended) => {
+	const buildNode = (name) => {
+		if (name.startsWith("@")) return {
+			type: MethodChainNodeTypes.CustomFunction,
+			name: name.slice(1),
+			params: []
+		};
+		return {
+			type: MethodChainNodeTypes.Identifier,
+			name
+		};
+	};
+	return {
+		type: MethodChainNodeTypes.Chain,
+		links: [...parentChain.links, typeof appended === "string" ? buildNode(appended) : appended]
+	};
+};
+const parseWithPartialOption = (path) => {
+	if (isValid(path)) {
+		const methodChain = parseMethodChain(path);
+		return {
+			methodChain: {
+				type: MethodChainNodeTypes.Chain,
+				links: methodChain.links.slice(0, methodChain.links.length - 1)
+			},
+			partial: last(methodChain.links)?.name || "",
+			valid: true
+		};
+	}
+	const rawParse = (input) => {
+		return normalizeChain(peg$parse(input, { strict: true }));
+	};
+	try {
+		if (path.endsWith(".")) return {
+			methodChain: rawParse(path.slice(0, -1)),
+			partial: "",
+			valid: true
+		};
+		if (path.lastIndexOf("[") > path.lastIndexOf("]")) {
+			const partialString = path.slice(path.lastIndexOf("[") + 2);
+			const partialValue = partialString.endsWith("'") ? partialString.slice(0, -1) : partialString;
+			return {
+				methodChain: rawParse(path.slice(0, path.lastIndexOf("["))),
+				partial: partialValue,
+				valid: true
+			};
+		}
+	} catch {}
+	return {
+		methodChain: EMPTY_METHOD_CHAIN,
+		partial: path,
+		valid: false
+	};
+};
+const pathIsNormative = (path) => {
+	return path.split(".").every((part) => /^[a-zA-Z0-9_-]+$/.test(part));
+};
+const getSyntaxError = () => peg$SyntaxError;
+const methodChainNodeToJsonSchema = (node) => {
+	if (node.type === MethodChainNodeTypes.String) return { type: "string" };
+	else if (node.type === MethodChainNodeTypes.Number) return { type: "number" };
+	else if (node.type === MethodChainNodeTypes.Array) if (node.items.length > 0) return {
+		type: "array",
+		items: node.items[0].type === MethodChainNodeTypes.String ? { type: "string" } : { type: "number" }
+	};
+	else return {
+		type: "array",
+		items: { type: "string" }
+	};
+	return null;
+};
+//#endregion
+export { EMPTY_METHOD_CHAIN, MethodChainNodeTypes, appendedMethodChain, containsFunctionNode, getFunctionParams, getSyntaxError, isArrayNode, isCustomFunctionNode, isEmpty, isFunctionNode, isIdentifierNode, isStringNode, isValid, methodChainCache, methodChainNodeToJsonSchema, methodChainRootName, methodChainToString, parseMethodChain, parseWithPartialOption, pathContainsFunctionNode, pathIsNormative, removeFunctionNode, tryParseMethodChain };
+
+//# sourceMappingURL=methodChain.mjs.map