@persona/design-system 0.7.2 → 0.8.0

package/dist/lib/jsonSchemaType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchemaType.mjs","names":[],"sources":["../../lib/jsonSchemaType.ts"],"sourcesContent":["import {\n  getNonNullableType,\n  isFileType,\n  isJsonSchemaArray,\n  isJsonSchemaString,\n  type JsonSchema,\n  type JsonSchemaTypes,\n  JsonSchemaAllTypes,\n  type JsonSchemaCustomTypes,\n} from './jsonSchema';\n\nexport const getJsonSchemaType = (\n  schema: JsonSchema | null,\n): JsonSchemaTypes | JsonSchemaCustomTypes => {\n  if (schema == null) {\n    return JsonSchemaAllTypes.Unknown;\n  }\n\n  if ('enum' in schema) {\n    return JsonSchemaAllTypes.Enum;\n  }\n  if ('anyOf' in schema && schema.anyOf.every((group: JsonSchema) => 'enum' in group)) {\n    return JsonSchemaAllTypes.GroupedEnum;\n  }\n  if ('type' in schema) {\n    // TODO(PLO-345): Union utilities across all non-`null` types in multi-non-null arrays\n    // (e.g. `[\"string\", \"number\", \"null\"]`) once runtime coercion semantics are confirmed.\n    if (Array.isArray(schema.type)) {\n      const nonNullable = getNonNullableType(schema);\n      if (!nonNullable) {\n        return JsonSchemaAllTypes.Unknown;\n      }\n      return getJsonSchemaType({ ...schema, type: nonNullable } as JsonSchema);\n    }\n    if (schema.type === JsonSchemaAllTypes.String && schema.format === 'date') {\n      return JsonSchemaAllTypes.Date;\n    }\n    if (schema.type === JsonSchemaAllTypes.String && schema.format === 'date-time') {\n      return JsonSchemaAllTypes.Datetime;\n    }\n    if (schema.type === JsonSchemaAllTypes.String && schema.format === 'secret') {\n      return JsonSchemaAllTypes.MaskedString;\n    }\n    if (schema.type === JsonSchemaAllTypes.Array && schema.uniqueItems && 'enum' in schema.items) {\n      return JsonSchemaAllTypes.MultiEnum;\n    }\n    if (schema.type === JsonSchemaAllTypes.Object && isFileType(schema.fieldType)) {\n      return JsonSchemaAllTypes.File;\n    }\n    if (\n      schema.type === JsonSchemaAllTypes.Object &&\n      typeof schema.fieldType === 'string' &&\n      schema.fieldType.startsWith('Field::Relation')\n    ) {\n      return JsonSchemaAllTypes.Relation;\n    }\n    if (isJsonSchemaString(schema) && 'oneOf' in schema) {\n      return JsonSchemaAllTypes.Enum;\n    }\n    if (isJsonSchemaArray(schema) && isJsonSchemaString(schema.items) && 'oneOf' in schema.items) {\n      return JsonSchemaAllTypes.MultiEnum;\n    }\n    return schema.type;\n  }\n  return JsonSchemaAllTypes.Unknown;\n};\n"],"mappings":";;AAWA,MAAa,qBACX,WAC4C;AAC5C,KAAI,UAAU,KACZ,QAAO,mBAAmB;AAG5B,KAAI,UAAU,OACZ,QAAO,mBAAmB;AAE5B,KAAI,WAAW,UAAU,OAAO,MAAM,OAAO,UAAsB,UAAU,MAAM,CACjF,QAAO,mBAAmB;AAE5B,KAAI,UAAU,QAAQ;AAGpB,MAAI,MAAM,QAAQ,OAAO,KAAK,EAAE;GAC9B,MAAM,cAAc,mBAAmB,OAAO;AAC9C,OAAI,CAAC,YACH,QAAO,mBAAmB;AAE5B,UAAO,kBAAkB;IAAE,GAAG;IAAQ,MAAM;IAAa,CAAe;;AAE1E,MAAI,OAAO,SAAS,mBAAmB,UAAU,OAAO,WAAW,OACjE,QAAO,mBAAmB;AAE5B,MAAI,OAAO,SAAS,mBAAmB,UAAU,OAAO,WAAW,YACjE,QAAO,mBAAmB;AAE5B,MAAI,OAAO,SAAS,mBAAmB,UAAU,OAAO,WAAW,SACjE,QAAO,mBAAmB;AAE5B,MAAI,OAAO,SAAS,mBAAmB,SAAS,OAAO,eAAe,UAAU,OAAO,MACrF,QAAO,mBAAmB;AAE5B,MAAI,OAAO,SAAS,mBAAmB,UAAU,WAAW,OAAO,UAAU,CAC3E,QAAO,mBAAmB;AAE5B,MACE,OAAO,SAAS,mBAAmB,UACnC,OAAO,OAAO,cAAc,YAC5B,OAAO,UAAU,WAAW,kBAAkB,CAE9C,QAAO,mBAAmB;AAE5B,MAAI,mBAAmB,OAAO,IAAI,WAAW,OAC3C,QAAO,mBAAmB;AAE5B,MAAI,kBAAkB,OAAO,IAAI,mBAAmB,OAAO,MAAM,IAAI,WAAW,OAAO,MACrF,QAAO,mBAAmB;AAE5B,SAAO,OAAO;;AAEhB,QAAO,mBAAmB"}

package/dist/lib/letPointerDownReachDocument.d.mts

@@ -0,0 +1,22 @@
+import { PointerEvent } from "react";
+
+//#region lib/letPointerDownReachDocument.d.ts
+/**
+ * `onPointerDownCapture` handler for a Radix dismissable layer (Popover,
+ * DropdownMenu, ...) that hosts react-aria pressables.
+ *
+ * react-aria's `usePress` stops `pointerdown` propagation, and React forwards
+ * that to the native event, so it never reaches `document`. Radix marks a
+ * pointerdown as "inside" during capture and only clears that mark from its
+ * `document` listener, so the mark survives and the next outside pointerdown
+ * is taken as inside: the layer needs a second outside click to dismiss.
+ *
+ * This keeps React-level propagation stopped (ancestor `usePress` handlers
+ * still skip the event) but lets the native event reach `document`.
+ */
+declare const letPointerDownReachDocument: ({
+  nativeEvent
+}: PointerEvent) => void;
+//#endregion
+export { letPointerDownReachDocument };
+//# sourceMappingURL=letPointerDownReachDocument.d.mts.map

package/dist/lib/letPointerDownReachDocument.mjs

@@ -0,0 +1,25 @@
+//#region lib/letPointerDownReachDocument.ts
+/**
+* `onPointerDownCapture` handler for a Radix dismissable layer (Popover,
+* DropdownMenu, ...) that hosts react-aria pressables.
+*
+* react-aria's `usePress` stops `pointerdown` propagation, and React forwards
+* that to the native event, so it never reaches `document`. Radix marks a
+* pointerdown as "inside" during capture and only clears that mark from its
+* `document` listener, so the mark survives and the next outside pointerdown
+* is taken as inside: the layer needs a second outside click to dismiss.
+*
+* This keeps React-level propagation stopped (ancestor `usePress` handlers
+* still skip the event) but lets the native event reach `document`.
+*/
+const letPointerDownReachDocument = ({ nativeEvent }) => {
+	if (Object.prototype.hasOwnProperty.call(nativeEvent, "stopPropagation")) return;
+	Object.defineProperty(nativeEvent, "stopPropagation", {
+		configurable: true,
+		value: () => void 0
+	});
+};
+//#endregion
+export { letPointerDownReachDocument };
+
+//# sourceMappingURL=letPointerDownReachDocument.mjs.map

package/dist/lib/letPointerDownReachDocument.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"letPointerDownReachDocument.mjs","names":[],"sources":["../../lib/letPointerDownReachDocument.ts"],"sourcesContent":["import type { PointerEvent as ReactPointerEvent } from 'react';\n\n/**\n * `onPointerDownCapture` handler for a Radix dismissable layer (Popover,\n * DropdownMenu, ...) that hosts react-aria pressables.\n *\n * react-aria's `usePress` stops `pointerdown` propagation, and React forwards\n * that to the native event, so it never reaches `document`. Radix marks a\n * pointerdown as \"inside\" during capture and only clears that mark from its\n * `document` listener, so the mark survives and the next outside pointerdown\n * is taken as inside: the layer needs a second outside click to dismiss.\n *\n * This keeps React-level propagation stopped (ancestor `usePress` handlers\n * still skip the event) but lets the native event reach `document`.\n */\nexport const letPointerDownReachDocument = ({ nativeEvent }: ReactPointerEvent): void => {\n  if (Object.prototype.hasOwnProperty.call(nativeEvent, 'stopPropagation')) {\n    return;\n  }\n  Object.defineProperty(nativeEvent, 'stopPropagation', {\n    configurable: true,\n    value: () => undefined,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,+BAA+B,EAAE,kBAA2C;AACvF,KAAI,OAAO,UAAU,eAAe,KAAK,aAAa,kBAAkB,CACtE;AAEF,QAAO,eAAe,aAAa,mBAAmB;EACpD,cAAc;EACd,aAAa,KAAA;EACd,CAAC"}

package/dist/lib/message.d.mts

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

package/dist/lib/methodChain.d.mts

@@ -1,66 +1,3 @@
-import { ASTNodeType } from "../components/SmartTextInput/parser/method-chain/types.mjs";
-import { n as JsonSchema } from "../jsonSchema-DmdZYC4a.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
+import { C as tryParseMethodChain, S as removeFunctionNode, _ as methodChainToString, a as getFunctionParams, b as pathContainsFunctionNode, c as isCustomFunctionNode, d as isIdentifierNode, f as isStringNode, g as methodChainRootName, h as methodChainNodeToJsonSchema, i as containsFunctionNode, l as isEmpty, m as methodChainCache, n as MethodChainNodeTypes, o as getSyntaxError, p as isValid, r as appendedMethodChain, s as isArrayNode, t as EMPTY_METHOD_CHAIN, u as isFunctionNode, v as parseMethodChain, x as pathIsNormative, y as parseWithPartialOption } from "../methodChain-Pk1C3i_E.mjs";
+import { a as FunctionParamType, c as NumberNode, i as FunctionNode, l as StringNode, n as Chain, o as IdentifierNode, r as CustomFunctionNode, s as MethodChainNode, t as ArrayNode } from "../methodChainTypes-CqWzfx0M.mjs";
+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 };

package/dist/lib/methodChain.mjs

@@ -1,239 +1,3 @@
-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
+import { C as tryParseMethodChain, S as removeFunctionNode, _ as methodChainToString, a as getFunctionParams, b as pathContainsFunctionNode, c as isCustomFunctionNode, d as isIdentifierNode, f as isStringNode, g as methodChainRootName, h as methodChainNodeToJsonSchema, i as containsFunctionNode, l as isEmpty, m as methodChainCache, n as MethodChainNodeTypes, o as getSyntaxError, p as isValid, r as appendedMethodChain, s as isArrayNode, t as EMPTY_METHOD_CHAIN, u as isFunctionNode, v as parseMethodChain, x as pathIsNormative, y as parseWithPartialOption } from "../methodChain-DAQxLgxt.mjs";
 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

package/dist/lib/methodChainNormalize.d.mts

@@ -1,5 +1,5 @@
-import { ASTArrayNode, ASTChain, ASTNumberNode, ASTStringNode } from "../components/SmartTextInput/parser/method-chain/types.mjs";
-import { Chain, FunctionParamType, NumberNode, StringNode } from "./methodChainTypes.mjs";
+import { d as ASTNumberNode, m as ASTStringNode, n as ASTChain, t as ASTArrayNode } from "../types-BGMmkUpy.mjs";
+import { a as FunctionParamType, c as NumberNode, l as StringNode, n as Chain } from "../methodChainTypes-CqWzfx0M.mjs";
 
 //#region lib/methodChainNormalize.d.ts
 declare function normalizeArrayItem(item: ASTStringNode | ASTNumberNode): StringNode | NumberNode;

package/dist/lib/methodChainTypes.d.mts

@@ -1,23 +1,2 @@
-import { ASTArrayNode, ASTChain, ASTCustomFunctionNode, ASTFunctionNode, ASTIdentifierNode, ASTNumberNode, ASTStringNode } from "../components/SmartTextInput/parser/method-chain/types.mjs";
-
-//#region lib/methodChainTypes.d.ts
-type MethodChainNode = IdentifierNode | FunctionNode | CustomFunctionNode;
-type FunctionParamType = Chain | StringNode | NumberNode | ArrayNode;
-type Chain = Omit<ASTChain, 'children' | 'start' | 'end'> & {
-  links: MethodChainNode[];
-};
-type StringNode = Omit<ASTStringNode, 'start' | 'end'>;
-type NumberNode = Omit<ASTNumberNode, 'start' | 'end'>;
-type ArrayNode = Omit<ASTArrayNode, 'children' | 'start' | 'end'> & {
-  items: (StringNode | NumberNode)[];
-};
-type IdentifierNode = Omit<ASTIdentifierNode, 'start' | 'end'>;
-type FunctionNode = Omit<ASTFunctionNode, 'children' | 'start' | 'end'> & {
-  params: FunctionParamType[];
-};
-type CustomFunctionNode = Omit<ASTCustomFunctionNode, 'children' | 'start' | 'end'> & {
-  params: FunctionParamType[];
-};
-//#endregion
-export { ArrayNode, Chain, CustomFunctionNode, FunctionNode, FunctionParamType, IdentifierNode, MethodChainNode, NumberNode, StringNode };
-//# sourceMappingURL=methodChainTypes.d.mts.map
+import { a as FunctionParamType, c as NumberNode, i as FunctionNode, l as StringNode, n as Chain, o as IdentifierNode, r as CustomFunctionNode, s as MethodChainNode, t as ArrayNode } from "../methodChainTypes-CqWzfx0M.mjs";
+export { ArrayNode, Chain, CustomFunctionNode, FunctionNode, FunctionParamType, IdentifierNode, MethodChainNode, NumberNode, StringNode };

package/dist/lib/objectSchemaTypes.d.mts

@@ -1,2 +1,2 @@
-import { at as FunctionReturnTypeJsonSchema, et as CollectionMetaJsonSchema, it as FunctionParameterJsonSchema, nt as FunctionGenericParameterSchema, ot as GenericType, rt as FunctionJsonSchema, st as ObjectSchemaMap, tt as FunctionConvertedTypeSchema } from "../jsonSchema-DmdZYC4a.mjs";
+import { at as FunctionConvertedTypeSchema, ct as FunctionParameterJsonSchema, dt as ObjectSchemaMap, it as CollectionMetaJsonSchema, lt as FunctionReturnTypeJsonSchema, ot as FunctionGenericParameterSchema, st as FunctionJsonSchema, ut as GenericType } from "../jsonSchema-CfGi1bzI.mjs";
 export { CollectionMetaJsonSchema, FunctionConvertedTypeSchema, FunctionGenericParameterSchema, FunctionJsonSchema, FunctionParameterJsonSchema, FunctionReturnTypeJsonSchema, GenericType, ObjectSchemaMap };

package/dist/lib/platformObject.d.mts

@@ -0,0 +1,38 @@
+import { S as JsonSchemaRef, b as JsonSchemaObjectKey, d as JsonSchemaCore, dt as ObjectSchemaMap, n as JsonSchema, u as JsonSchemaConst, y as JsonSchemaObject } from "../jsonSchema-CfGi1bzI.mjs";
+
+//#region lib/platformObject.d.ts
+interface PlatformObjectJsonSchema extends JsonSchemaObject {
+  properties: {
+    objectType: {
+      const: JsonSchemaObjectKey;
+    };
+    template?: {
+      anyOf: JsonSchemaConst[];
+    };
+  };
+  required: string[];
+}
+type PlatformJsonSchema = JsonSchemaCore | PlatformObjectJsonSchema;
+declare const MERGED_SCHEMA_ID = "merged";
+declare const setSchemaPropertyDescriptionResolver: (resolver: (propertyKey: string) => string | undefined) => void;
+declare const injectPropertyDescriptions: (schema: JsonSchemaObject) => JsonSchemaObject;
+declare const isPlatformObjectSchema: (schema: JsonSchema) => schema is PlatformObjectJsonSchema;
+declare const getPlatformObjectTypeFromJsonSchema: (schema: JsonSchema) => JsonSchemaObjectKey | null;
+declare const getPlatformTemplateFromJsonSchema: (schema: JsonSchema) => string[] | null;
+declare const getSpecificType: (schema: PlatformJsonSchema) => string;
+declare const resolveJssRef: (schema: JsonSchemaRef, platformObjectJsonSchema?: ObjectSchemaMap) => JsonSchemaObject;
+declare const getWorkflowObjectKeyFromSchemaRef: (schemaRef: string) => JsonSchemaObjectKey;
+declare const getSchemaId: (workflowObjectKey: JsonSchemaObjectKey | string, identifier?: string) => string;
+declare enum PrimitiveSchemaId {
+  String = "/schema/string",
+  Array = "/schema/array",
+  Number = "/schema/number",
+  Boolean = "/schema/boolean",
+  Date = "/schema/date",
+  Datetime = "/schema/datetime",
+  File = "/schema/field/file"
+}
+declare const getSchemaIdForExternalIntegration: (vendor: string, operation: string) => string;
+//#endregion
+export { MERGED_SCHEMA_ID, PlatformJsonSchema, PlatformObjectJsonSchema, PrimitiveSchemaId, getPlatformObjectTypeFromJsonSchema, getPlatformTemplateFromJsonSchema, getSchemaId, getSchemaIdForExternalIntegration, getSpecificType, getWorkflowObjectKeyFromSchemaRef, injectPropertyDescriptions, isPlatformObjectSchema, resolveJssRef, setSchemaPropertyDescriptionResolver };
+//# sourceMappingURL=platformObject.d.mts.map

package/dist/lib/platformObject.mjs

@@ -0,0 +1,79 @@
+import { EMPTY_JSON_SCHEMA_OBJECT, isJsonSchemaRef } from "./jsonSchema.mjs";
+import { getJsonSchemaType } from "./jsonSchemaType.mjs";
+import { snakify } from "./snakifyPath.mjs";
+import { snakeCase } from "lodash-es";
+//#region lib/platformObject.ts
+const MERGED_SCHEMA_ID = "merged";
+let schemaPropertyDescriptionResolver = (_propertyKey) => void 0;
+let propertyDescriptionCache = /* @__PURE__ */ new WeakMap();
+const setSchemaPropertyDescriptionResolver = (resolver) => {
+	if (resolver === schemaPropertyDescriptionResolver) return;
+	schemaPropertyDescriptionResolver = resolver;
+	propertyDescriptionCache = /* @__PURE__ */ new WeakMap();
+};
+const injectPropertyDescriptions = (schema) => {
+	const cachedSchema = propertyDescriptionCache.get(schema);
+	if (cachedSchema) return cachedSchema;
+	const schemaWithDescriptions = {
+		...schema,
+		properties: Object.entries(schema.properties).reduce((acc, [propertyKey, propertySchema]) => ({
+			...acc,
+			[propertyKey]: {
+				...propertySchema,
+				description: isJsonSchemaRef(propertySchema) ? `Type: ${propertySchema.description}` : propertySchema.description ?? schemaPropertyDescriptionResolver(propertyKey)
+			}
+		}), {})
+	};
+	propertyDescriptionCache.set(schema, schemaWithDescriptions);
+	return schemaWithDescriptions;
+};
+const isPlatformObjectSchema = (schema) => {
+	return "type" in schema && schema.type === "object" && schema.properties && "objectType" in schema.properties;
+};
+const getPlatformObjectTypeFromJsonSchema = (schema) => {
+	return isPlatformObjectSchema(schema) ? schema.properties.objectType.const : null;
+};
+const getPlatformTemplateFromJsonSchema = (schema) => {
+	if (!isPlatformObjectSchema(schema)) return null;
+	return schema.properties.template?.anyOf.map((jsonSchema) => jsonSchema.const) || null;
+};
+const getSpecificType = (schema) => {
+	const platformObjectType = getPlatformObjectTypeFromJsonSchema(schema);
+	if (platformObjectType) return platformObjectType;
+	return getJsonSchemaType(schema);
+};
+const resolveJssRef = (schema, platformObjectJsonSchema = {}) => {
+	return platformObjectJsonSchema[schema.$ref] ? injectPropertyDescriptions(platformObjectJsonSchema[schema.$ref]) : EMPTY_JSON_SCHEMA_OBJECT;
+};
+const getWorkflowObjectKeyFromSchemaRef = (schemaRef) => {
+	return schemaRef.split("/").slice(2).slice(0, -1).join("/").replace(/_/g, "-");
+};
+const getSchemaId = (workflowObjectKey, identifier = "") => {
+	return [
+		"/schema",
+		snakify(workflowObjectKey),
+		identifier
+	].filter(Boolean).join("/");
+};
+let PrimitiveSchemaId = /* @__PURE__ */ function(PrimitiveSchemaId) {
+	PrimitiveSchemaId["String"] = "/schema/string";
+	PrimitiveSchemaId["Array"] = "/schema/array";
+	PrimitiveSchemaId["Number"] = "/schema/number";
+	PrimitiveSchemaId["Boolean"] = "/schema/boolean";
+	PrimitiveSchemaId["Date"] = "/schema/date";
+	PrimitiveSchemaId["Datetime"] = "/schema/datetime";
+	PrimitiveSchemaId["File"] = "/schema/field/file";
+	return PrimitiveSchemaId;
+}({});
+const getSchemaIdForExternalIntegration = (vendor, operation) => {
+	return vendor && operation ? [
+		"/schema",
+		"external_integration_log",
+		snakeCase(vendor),
+		operation
+	].filter(Boolean).join("/") : "";
+};
+//#endregion
+export { MERGED_SCHEMA_ID, PrimitiveSchemaId, getPlatformObjectTypeFromJsonSchema, getPlatformTemplateFromJsonSchema, getSchemaId, getSchemaIdForExternalIntegration, getSpecificType, getWorkflowObjectKeyFromSchemaRef, injectPropertyDescriptions, isPlatformObjectSchema, resolveJssRef, setSchemaPropertyDescriptionResolver };
+
+//# sourceMappingURL=platformObject.mjs.map

package/dist/lib/platformObject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"platformObject.mjs","names":[],"sources":["../../lib/platformObject.ts"],"sourcesContent":["import { snakeCase } from 'lodash-es';\n\nimport {\n  EMPTY_JSON_SCHEMA_OBJECT,\n  type JsonSchema,\n  type JsonSchemaConst,\n  type JsonSchemaCore,\n  type JsonSchemaObject,\n  type JsonSchemaRef,\n  isJsonSchemaRef,\n  JsonSchemaTypes,\n  type JsonSchemaObjectKey,\n} from './jsonSchema';\nimport { getJsonSchemaType } from './jsonSchemaType';\nimport type { ObjectSchemaMap } from './objectSchemaTypes';\nimport { snakify } from './snakifyPath';\n\nexport interface PlatformObjectJsonSchema extends JsonSchemaObject {\n  properties: {\n    objectType: {\n      const: JsonSchemaObjectKey;\n    };\n    template?: {\n      anyOf: JsonSchemaConst[];\n    };\n  };\n  required: string[];\n}\n\nexport type PlatformJsonSchema = JsonSchemaCore | PlatformObjectJsonSchema;\n\nexport const MERGED_SCHEMA_ID = 'merged';\n\nlet schemaPropertyDescriptionResolver = (_propertyKey: string): string | undefined => undefined;\nlet propertyDescriptionCache = new WeakMap<JsonSchemaObject, JsonSchemaObject>();\n\nexport const setSchemaPropertyDescriptionResolver = (\n  resolver: (propertyKey: string) => string | undefined,\n): void => {\n  if (resolver === schemaPropertyDescriptionResolver) {\n    return;\n  }\n  schemaPropertyDescriptionResolver = resolver;\n  propertyDescriptionCache = new WeakMap();\n};\n\nexport const injectPropertyDescriptions = (schema: JsonSchemaObject): JsonSchemaObject => {\n  const cachedSchema = propertyDescriptionCache.get(schema);\n  if (cachedSchema) {\n    return cachedSchema;\n  }\n\n  const schemaWithDescriptions = {\n    ...schema,\n    properties: Object.entries(schema.properties).reduce<JsonSchemaObject['properties']>(\n      (acc, [propertyKey, propertySchema]) => ({\n        ...acc,\n        [propertyKey]: {\n          ...propertySchema,\n          description: isJsonSchemaRef(propertySchema)\n            ? `Type: ${propertySchema.description}`\n            : (propertySchema.description ?? schemaPropertyDescriptionResolver(propertyKey)),\n        },\n      }),\n      {},\n    ),\n  };\n  propertyDescriptionCache.set(schema, schemaWithDescriptions);\n  return schemaWithDescriptions;\n};\n\nexport const isPlatformObjectSchema = (schema: JsonSchema): schema is PlatformObjectJsonSchema => {\n  return (\n    'type' in schema &&\n    schema.type === JsonSchemaTypes.Object &&\n    schema.properties &&\n    'objectType' in schema.properties\n  );\n};\n\nexport const getPlatformObjectTypeFromJsonSchema = (\n  schema: JsonSchema,\n): JsonSchemaObjectKey | null => {\n  return isPlatformObjectSchema(schema) ? schema.properties.objectType.const : null;\n};\n\nexport const getPlatformTemplateFromJsonSchema = (schema: JsonSchema): string[] | null => {\n  if (!isPlatformObjectSchema(schema)) {\n    return null;\n  }\n  return schema.properties.template?.anyOf.map((jsonSchema) => jsonSchema.const) || null;\n};\n\nexport const getSpecificType = (schema: PlatformJsonSchema) => {\n  const platformObjectType = getPlatformObjectTypeFromJsonSchema(schema);\n  if (platformObjectType) {\n    return platformObjectType;\n  }\n  return getJsonSchemaType(schema);\n};\n\nexport const resolveJssRef = (\n  schema: JsonSchemaRef,\n  platformObjectJsonSchema: ObjectSchemaMap = {},\n): JsonSchemaObject => {\n  return platformObjectJsonSchema[schema.$ref]\n    ? injectPropertyDescriptions(platformObjectJsonSchema[schema.$ref])\n    : EMPTY_JSON_SCHEMA_OBJECT;\n};\n\n// This is a hack to get the JSON:API name of the Persona object described by the schema\n// returned from the workflows schema controller.\nexport const getWorkflowObjectKeyFromSchemaRef = (schemaRef: string): JsonSchemaObjectKey => {\n  return schemaRef\n    .split('/') // ['', 'schema', 'object-type', 'object-subtype', 'merged']\n    .slice(2) // ['object-type', 'object-subtype', 'merged']\n    .slice(0, -1) // ['object-type', 'object-subtype']\n    .join('/')\n    .replace(/_/g, '-') as JsonSchemaObjectKey;\n};\n\nexport const getSchemaId = (\n  workflowObjectKey: JsonSchemaObjectKey | string,\n  identifier = '',\n): string => {\n  return ['/schema', snakify(workflowObjectKey), identifier].filter(Boolean).join('/');\n};\n\nexport enum PrimitiveSchemaId {\n  String = '/schema/string',\n  Array = '/schema/array',\n  Number = '/schema/number',\n  Boolean = '/schema/boolean',\n  Date = '/schema/date',\n  Datetime = '/schema/datetime',\n  File = '/schema/field/file',\n}\n\nexport const getSchemaIdForExternalIntegration = (vendor: string, operation: string): string => {\n  return vendor && operation\n    ? ['/schema', 'external_integration_log', snakeCase(vendor), operation]\n        .filter(Boolean)\n        .join('/')\n    : '';\n};\n"],"mappings":";;;;;AA+BA,MAAa,mBAAmB;AAEhC,IAAI,qCAAqC,iBAA6C,KAAA;AACtF,IAAI,2CAA2B,IAAI,SAA6C;AAEhF,MAAa,wCACX,aACS;AACT,KAAI,aAAa,kCACf;AAEF,qCAAoC;AACpC,4CAA2B,IAAI,SAAS;;AAG1C,MAAa,8BAA8B,WAA+C;CACxF,MAAM,eAAe,yBAAyB,IAAI,OAAO;AACzD,KAAI,aACF,QAAO;CAGT,MAAM,yBAAyB;EAC7B,GAAG;EACH,YAAY,OAAO,QAAQ,OAAO,WAAW,CAAC,QAC3C,KAAK,CAAC,aAAa,qBAAqB;GACvC,GAAG;IACF,cAAc;IACb,GAAG;IACH,aAAa,gBAAgB,eAAe,GACxC,SAAS,eAAe,gBACvB,eAAe,eAAe,kCAAkC,YAAY;IAClF;GACF,GACD,EAAE,CACH;EACF;AACD,0BAAyB,IAAI,QAAQ,uBAAuB;AAC5D,QAAO;;AAGT,MAAa,0BAA0B,WAA2D;AAChG,QACE,UAAU,UACV,OAAO,SAAA,YACP,OAAO,cACP,gBAAgB,OAAO;;AAI3B,MAAa,uCACX,WAC+B;AAC/B,QAAO,uBAAuB,OAAO,GAAG,OAAO,WAAW,WAAW,QAAQ;;AAG/E,MAAa,qCAAqC,WAAwC;AACxF,KAAI,CAAC,uBAAuB,OAAO,CACjC,QAAO;AAET,QAAO,OAAO,WAAW,UAAU,MAAM,KAAK,eAAe,WAAW,MAAM,IAAI;;AAGpF,MAAa,mBAAmB,WAA+B;CAC7D,MAAM,qBAAqB,oCAAoC,OAAO;AACtE,KAAI,mBACF,QAAO;AAET,QAAO,kBAAkB,OAAO;;AAGlC,MAAa,iBACX,QACA,2BAA4C,EAAE,KACzB;AACrB,QAAO,yBAAyB,OAAO,QACnC,2BAA2B,yBAAyB,OAAO,MAAM,GACjE;;AAKN,MAAa,qCAAqC,cAA2C;AAC3F,QAAO,UACJ,MAAM,IAAI,CACV,MAAM,EAAE,CACR,MAAM,GAAG,GAAG,CACZ,KAAK,IAAI,CACT,QAAQ,MAAM,IAAI;;AAGvB,MAAa,eACX,mBACA,aAAa,OACF;AACX,QAAO;EAAC;EAAW,QAAQ,kBAAkB;EAAE;EAAW,CAAC,OAAO,QAAQ,CAAC,KAAK,IAAI;;AAGtF,IAAY,oBAAL,yBAAA,mBAAA;AACL,mBAAA,YAAA;AACA,mBAAA,WAAA;AACA,mBAAA,YAAA;AACA,mBAAA,aAAA;AACA,mBAAA,UAAA;AACA,mBAAA,cAAA;AACA,mBAAA,UAAA;;KACD;AAED,MAAa,qCAAqC,QAAgB,cAA8B;AAC9F,QAAO,UAAU,YACb;EAAC;EAAW;EAA4B,UAAU,OAAO;EAAE;EAAU,CAClE,OAAO,QAAQ,CACf,KAAK,IAAI,GACZ"}

package/dist/lib/pseudoClass.d.mts

@@ -1,4 +1,4 @@
-import { t as PseudoClassProps } from "../PseudoClassProps-CHtBNv8B.mjs";
+import { t as PseudoClassProps } from "../PseudoClassProps-BHs8TX_3.mjs";
 
 //#region lib/pseudoClass.d.ts
 declare const isDisabled: ({

package/dist/lib/router/adapters/reactRouter.d.mts

@@ -1,4 +1,4 @@
-import { n as RouterAdapter } from "../../../types-B-stjYNc.mjs";
+import { n as RouterAdapter } from "../../../types-CkpixGWr.mjs";
 import { FC, PropsWithChildren } from "react";
 
 //#region lib/router/adapters/reactRouter.d.ts

package/dist/lib/router/adapters/tanstack.d.mts

@@ -1,4 +1,4 @@
-import { n as RouterAdapter } from "../../../types-B-stjYNc.mjs";
+import { n as RouterAdapter } from "../../../types-CkpixGWr.mjs";
 import { FC, PropsWithChildren } from "react";
 
 //#region lib/router/adapters/tanstack.d.ts

package/dist/lib/router/index.d.mts

@@ -1,6 +1,6 @@
-import { i as To, n as RouterAdapter, r as RouterLinkComponentProps, t as NavigateOptions } from "../../types-B-stjYNc.mjs";
-import { n as RouterProvider, r as useRouter, t as RouterContext } from "../../RouterContext-CbvHIl4K.mjs";
-import { t as createPath } from "../../createPath-Bst12Uxr.mjs";
-import { t as RouterLink } from "../../RouterLink-v9AG9fYa.mjs";
-import { t as usePathname } from "../../useLocationPathname-CnRd_Rzn.mjs";
+import { i as To, n as RouterAdapter, r as RouterLinkComponentProps, t as NavigateOptions } from "../../types-CkpixGWr.mjs";
+import { n as RouterProvider, r as useRouter, t as RouterContext } from "../../RouterContext-B3IU1jb0.mjs";
+import { t as createPath } from "../../createPath-OeTC9kvS.mjs";
+import { t as RouterLink } from "../../RouterLink-CwAqTLC2.mjs";
+import { t as usePathname } from "../../useLocationPathname-DH5Tdq5X.mjs";
 export { NavigateOptions, RouterAdapter, RouterContext, RouterLink, RouterLinkComponentProps, RouterProvider, To, createPath, usePathname, useRouter };