@persona/design-system 0.7.2 → 0.8.1

package/dist/listbox-options-BjOkovND.d.mts

@@ -0,0 +1,38 @@
+import { n as PossibleChainSchema } from "./chainTypes-D8SGRGba.mjs";
+import { a as Mode, u as ValueType } from "./types-Cs6CdZCO.mjs";
+
+//#region components/SmartTextInput/listbox-options.d.ts
+type MethodChainOption = {
+  id: string;
+  type: 'method-chain-option';
+  ariaLabel: string;
+  label: string;
+  returnType: string | undefined;
+  description: string | undefined;
+  interactive: boolean;
+  disabled: boolean;
+};
+type ContextMenuOption = {
+  id: string;
+  type: 'context-menu-option';
+  ariaLabel: string;
+  label: string;
+  returnType: string;
+  description: string | undefined;
+  interactive: boolean;
+  disabled: boolean;
+};
+type SmartTextInputOption = ContextMenuOption | MethodChainOption;
+declare const EXIT_METHOD_CHAIN_VALUE_TYPE_OPTION: MethodChainOption;
+declare const isContextMenuOption: (item: SmartTextInputOption) => item is ContextMenuOption;
+declare const isMethodChainOption: (item: SmartTextInputOption) => item is MethodChainOption;
+type ContextMenuExamples = {
+  code?: string;
+  handlebars?: string;
+  methodChain?: string;
+};
+declare const getContextMenuOptions: (valueIsEmpty: boolean, allowedValueType: ValueType | undefined, allowedInterpolationModes: (Mode.MethodChain | Mode.Code)[] | undefined, examples?: ContextMenuExamples) => ContextMenuOption[];
+declare const getMethodChainOptions: (options: PossibleChainSchema[]) => MethodChainOption[];
+//#endregion
+export { SmartTextInputOption as a, isContextMenuOption as c, MethodChainOption as i, isMethodChainOption as l, ContextMenuOption as n, getContextMenuOptions as o, EXIT_METHOD_CHAIN_VALUE_TYPE_OPTION as r, getMethodChainOptions as s, ContextMenuExamples as t };
+//# sourceMappingURL=listbox-options-BjOkovND.d.mts.map

package/dist/listbox-options.d.mts

@@ -0,0 +1,2 @@
+import { a as SmartTextInputOption, c as isContextMenuOption, i as MethodChainOption, l as isMethodChainOption, n as ContextMenuOption, o as getContextMenuOptions, r as EXIT_METHOD_CHAIN_VALUE_TYPE_OPTION, s as getMethodChainOptions, t as ContextMenuExamples } from "./listbox-options-BjOkovND.mjs";
+export { ContextMenuExamples, ContextMenuOption, EXIT_METHOD_CHAIN_VALUE_TYPE_OPTION, MethodChainOption, SmartTextInputOption, getContextMenuOptions, getMethodChainOptions, isContextMenuOption, isMethodChainOption };

package/dist/{message-CKSLIKF0.d.mts → message-w_1-kTDE.d.mts}

@@ -6,4 +6,4 @@ declare enum MessageType {
 }
 //#endregion
 export { MessageType as t };
-//# sourceMappingURL=message-CKSLIKF0.d.mts.map
+//# sourceMappingURL=message-w_1-kTDE.d.mts.map

package/dist/methodChain-B5vZEOff.d.mts

@@ -0,0 +1,66 @@
+import { u as ASTNodeType } from "./types-M-rsm1Km.mjs";
+import { n as JsonSchema } from "./jsonSchema-Bl-qzgrr.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-BVkTI8MX.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 { tryParseMethodChain as C, removeFunctionNode as S, methodChainToString as _, getFunctionParams as a, pathContainsFunctionNode as b, isCustomFunctionNode as c, isIdentifierNode as d, isStringNode as f, methodChainRootName as g, methodChainNodeToJsonSchema as h, containsFunctionNode as i, isEmpty as l, methodChainCache as m, MethodChainNodeTypes as n, getSyntaxError as o, isValid as p, appendedMethodChain as r, isArrayNode as s, EMPTY_METHOD_CHAIN as t, isFunctionNode as u, parseMethodChain as v, pathIsNormative as x, parseWithPartialOption as y };
+//# sourceMappingURL=methodChain-B5vZEOff.d.mts.map

package/dist/methodChain-L_h8Z8Bx.mjs

@@ -0,0 +1,241 @@
+import { i as peg$parse, n as peg$SyntaxError } from "./parser-BeTiVjRs.mjs";
+import "./lib/jsonSchema.mjs";
+import { reportError } from "./lib/errorReporter.mjs";
+import "./components/SmartTextInput/parser/method-chain/types.mjs";
+import { normalizeChain } from "./lib/methodChainNormalize.mjs";
+import { last } from "lodash-es";
+//#region lib/assertNever.ts
+function assertNever(value) {
+	const dump = typeof value === "object" ? JSON.stringify(value) : value;
+	reportError(/* @__PURE__ */ new TypeError(`assertNever non-exhaustive match: ${dump}`));
+}
+//#endregion
+//#region lib/methodChain.ts
+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$1 = (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 { tryParseMethodChain as C, removeFunctionNode as S, methodChainToString as _, getFunctionParams as a, pathContainsFunctionNode as b, isCustomFunctionNode as c, isIdentifierNode as d, isStringNode as f, methodChainRootName as g, methodChainNodeToJsonSchema as h, containsFunctionNode as i, isEmpty$1 as l, methodChainCache as m, MethodChainNodeTypes as n, getSyntaxError as o, isValid as p, appendedMethodChain as r, isArrayNode as s, EMPTY_METHOD_CHAIN as t, isFunctionNode as u, parseMethodChain as v, assertNever as w, pathIsNormative as x, parseWithPartialOption as y };
+
+//# sourceMappingURL=methodChain-L_h8Z8Bx.mjs.map

package/dist/methodChain-L_h8Z8Bx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"methodChain-L_h8Z8Bx.mjs","names":["isEmpty","updatedParse","UpdatedSyntaxError"],"sources":["../lib/assertNever.ts","../lib/methodChain.ts"],"sourcesContent":["import { reportError } from './errorReporter';\n\n// @ts-expect-error Returns never so the compiler checks exhaustiveness, but doesn't throw so a malformed\n// value degrades instead of breaking render.\nexport function assertNever(value: never): never {\n  const dump = typeof value === 'object' ? JSON.stringify(value) : value;\n  reportError(new TypeError(`assertNever non-exhaustive match: ${dump}`));\n}\n","import { last } from 'lodash-es';\n\nimport {\n  parse as updatedParse,\n  SyntaxError as UpdatedSyntaxError,\n} from '@persona/design-system/components/SmartTextInput/parser/method-chain/parser';\nimport { ASTNodeType } from '@persona/design-system/components/SmartTextInput/parser/method-chain/types';\n\nimport { assertNever } from './assertNever';\nimport { type JsonSchema, JsonSchemaTypes } from './jsonSchema';\nimport { normalizeChain } from './methodChainNormalize';\nimport type {\n  Chain,\n  FunctionNode,\n  CustomFunctionNode,\n  IdentifierNode,\n  StringNode,\n  NumberNode,\n  ArrayNode,\n  FunctionParamType,\n  MethodChainNode,\n} from './methodChainTypes';\n\n// Re-export types for backward compatibility\nexport {\n  Chain,\n  FunctionNode,\n  CustomFunctionNode,\n  IdentifierNode,\n  StringNode,\n  NumberNode,\n  ArrayNode,\n  FunctionParamType,\n  MethodChainNode,\n};\n\nexport const methodChainCache: { [key: string]: Chain } = {};\n\nexport const MethodChainNodeTypes = {\n  Chain: ASTNodeType.Chain,\n  String: ASTNodeType.String,\n  Number: ASTNodeType.Number,\n  Identifier: ASTNodeType.Identifier,\n  Function: ASTNodeType.Function,\n  CustomFunction: ASTNodeType.CustomFunction,\n  Array: ASTNodeType.Array,\n} as const;\n\nexport const EMPTY_METHOD_CHAIN: Chain = {\n  type: MethodChainNodeTypes.Chain,\n  links: [],\n};\n\ntype MethodChainLiteral = string | number | (string | number)[];\n\nexport const isFunctionNode = (node: MethodChainNode): node is FunctionNode =>\n  node.type === MethodChainNodeTypes.Function;\n\nexport const isCustomFunctionNode = (node: MethodChainNode): node is CustomFunctionNode =>\n  node.type === MethodChainNodeTypes.CustomFunction;\n\nexport const isIdentifierNode = (node: MethodChainNode): node is IdentifierNode =>\n  node.type === MethodChainNodeTypes.Identifier;\n\nexport const isStringNode = (node: FunctionParamType): node is StringNode =>\n  node.type === MethodChainNodeTypes.String;\n\nexport const isArrayNode = (node: FunctionParamType): node is ArrayNode =>\n  node.type === MethodChainNodeTypes.Array;\n\nexport const containsFunctionNode = (methodChain: Chain, ...functionNames: string[]): boolean =>\n  methodChain.links.some((link) => isFunctionNode(link) && functionNames.includes(link.name));\n\n/**\n * Returns true if the string contains any function node (e.g. `.at(...)`) when parsed\n * as a method chain. Use this to detect whether a field path must be treated as an\n * opaque key rather than split on `.` for Lodash set/get operations.\n */\nexport const pathContainsFunctionNode = (path: string): boolean => {\n  try {\n    const chain = parseMethodChain(path);\n    return chain.links.some(\n      (link) =>\n        link.type === MethodChainNodeTypes.Function ||\n        link.type === MethodChainNodeTypes.CustomFunction,\n    );\n  } catch {\n    return false;\n  }\n};\n\nexport const isEmpty = (methodChain: Chain): boolean => methodChain.links.length === 0;\n\nexport const getFunctionParams = (\n  methodChain: Chain,\n  ...functionNames: string[]\n): Record<string, MethodChainLiteral[]> => {\n  return Object.fromEntries(\n    methodChain.links\n      .filter((link) => isFunctionNode(link))\n      .filter((link) => functionNames.includes(link.name))\n      .map((link) => [link.name, flattenParamsToString(link.params)]),\n  );\n};\n\nexport const removeFunctionNode = (methodChain: Chain, functionName: string): Chain => {\n  return {\n    type: MethodChainNodeTypes.Chain,\n    links: methodChain.links.filter(\n      (link) => link.type !== MethodChainNodeTypes.Function || link.name !== functionName,\n    ),\n  };\n};\n\nconst flattenParamsToString = (params: FunctionParamType[]): MethodChainLiteral[] => {\n  const result: MethodChainLiteral[] = [];\n\n  for (const param of params) {\n    switch (param.type) {\n      case MethodChainNodeTypes.Chain:\n        result.push(...flattenChainToString(param));\n        break;\n      case MethodChainNodeTypes.String:\n      case MethodChainNodeTypes.Number:\n        result.push(param.value);\n        break;\n      case MethodChainNodeTypes.Array:\n        result.push(param.items.map((item) => item.value));\n        break;\n    }\n  }\n\n  return result;\n};\n\nconst flattenChainToString = (methodChain: Chain): MethodChainLiteral[] =>\n  methodChain.links\n    .map((link) => {\n      switch (link.type) {\n        case MethodChainNodeTypes.Function:\n        case MethodChainNodeTypes.CustomFunction:\n          return flattenParamsToString(link.params);\n        case MethodChainNodeTypes.Identifier:\n          return link.name;\n      }\n    })\n    .flat();\n\nexport const isValid = (methodChain: string): boolean => {\n  try {\n    parseMethodChain(methodChain);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * The parsed chain, or undefined when it will not parse. Callers that read a chain while it is being\n * authored hold half-typed input, where a throw is noise rather than an error.\n */\nexport const tryParseMethodChain = (methodChain: string): Chain | undefined => {\n  try {\n    return parseMethodChain(methodChain);\n  } catch {\n    return undefined;\n  }\n};\n\n/** The object a chain is rooted at: `current_case.inquiries` -> `current_case`. */\nexport const methodChainRootName = (methodChain: string): string | undefined => {\n  const [root] = tryParseMethodChain(methodChain)?.links ?? [];\n  return root && isIdentifierNode(root) ? root.name : undefined;\n};\n\nexport const parseMethodChain = (methodChain: string): Chain => {\n  if (!methodChain || methodChain === '') {\n    return EMPTY_METHOD_CHAIN;\n  }\n\n  if (!methodChainCache[methodChain]) {\n    methodChainCache[methodChain] = normalizeChain(updatedParse(methodChain, { strict: true }));\n  }\n  return methodChainCache[methodChain];\n};\n\nconst memberToString = (value: string): string => {\n  return `'${value.replace(/'/g, \"\\\\'\")}'`;\n};\n\n// Number#toString gives the shortest decimal string that round-trips back to the same\n// float64, but for magnitudes below 1e-6 (or above 1e21) it switches to exponential\n// notation (e.g. `0.0000001` -> \"1e-7\"), which the method chain grammar's plain-decimal\n// literal can't parse. Expand that exponential form back into plain decimal by shifting\n// its digits, rather than capping fraction digits (e.g. via toLocaleString), which silently\n// rounds magnitudes below the cap to \"0\" instead of reproducing them.\nconst expandExponentialNotation = (str: string): string => {\n  const match = /^(-?)(\\d)(?:\\.(\\d+))?e([+-]\\d+)$/.exec(str);\n  if (!match) {\n    return str;\n  }\n  const [, sign, leadingDigit, fractionDigits = '', exponentStr] = match;\n  const digits = leadingDigit + fractionDigits;\n  const exponent = Number(exponentStr);\n\n  if (exponent < 0) {\n    return `${sign}0.${'0'.repeat(-exponent - 1)}${digits}`;\n  }\n  // Positive exponential notation only appears at exponent >= 21 (Number#toString's own\n  // threshold), while a double's mantissa never carries more than 17 significant digits,\n  // so the exponent always reaches past the end of `digits` — there's no case where the\n  // decimal point lands inside them.\n  return `${sign}${digits}${'0'.repeat(exponent - fractionDigits.length)}`;\n};\n\nconst numberLiteralToString = (value: number): string => {\n  // The grammar has no literal for Infinity/NaN; render/label call sites have no way to\n  // recover from a throw, so fall back to JS's own string form instead of crashing them.\n  if (!Number.isFinite(value)) {\n    return `${value}`;\n  }\n\n  const str = value.toString();\n  return /e/i.test(str) ? expandExponentialNotation(str) : str;\n};\n\nexport const methodChainToString = (\n  methodChain: Chain | StringNode | NumberNode | ArrayNode,\n): string => {\n  switch (methodChain.type) {\n    case MethodChainNodeTypes.String:\n      return methodChain.value;\n    case MethodChainNodeTypes.Number:\n      return numberLiteralToString(methodChain.value);\n    case MethodChainNodeTypes.Array:\n      return `[${methodChain.items\n        .map((item) =>\n          item.type === MethodChainNodeTypes.String\n            ? memberToString(item.value)\n            : `#${numberLiteralToString(item.value)}`,\n        )\n        .join(', ')}]`;\n    default: {\n      const regex = new RegExp('^@?[a-zA-Z0-9_-]+$');\n      return methodChain.links\n        .map((link, index) => {\n          switch (link.type) {\n            case MethodChainNodeTypes.Identifier: {\n              const fullName = `${link.prefix ?? ''}${link.name}`;\n              return index === 0\n                ? fullName\n                : regex.test(fullName)\n                  ? `.${fullName}`\n                  : `['${fullName.replace(/'/g, \"\\\\'\")}']`;\n            }\n            case MethodChainNodeTypes.Function: {\n              return `.${link.name}(${link.params\n                .map((param) => {\n                  switch (param.type) {\n                    case MethodChainNodeTypes.String:\n                      return memberToString(param.value);\n                    case MethodChainNodeTypes.Number:\n                      return `#${numberLiteralToString(param.value)}`;\n                    case MethodChainNodeTypes.Chain:\n                    case MethodChainNodeTypes.Array:\n                      return methodChainToString(param);\n                  }\n                })\n                .join(', ')})`;\n            }\n            case MethodChainNodeTypes.CustomFunction: {\n              const paramStr = link.params\n                .map((param) => {\n                  switch (param.type) {\n                    case MethodChainNodeTypes.String:\n                      return memberToString(param.value);\n                    case MethodChainNodeTypes.Number:\n                      return `#${numberLiteralToString(param.value)}`;\n                    case MethodChainNodeTypes.Chain:\n                    case MethodChainNodeTypes.Array:\n                      return methodChainToString(param);\n                  }\n                })\n                .join(', ');\n              return [\n                index === 0 ? '' : '.',\n                `@${link.name}`,\n                link.params.length === 0 ? '' : `(${paramStr})`,\n              ].join('');\n            }\n            default:\n              assertNever(link);\n          }\n        })\n        .join('');\n    }\n  }\n};\n\nexport const appendedMethodChain = (\n  parentChain: Chain,\n  appended: string | MethodChainNode,\n): Chain => {\n  const buildNode = (name: string): MethodChainNode => {\n    if (name.startsWith('@')) {\n      return { type: MethodChainNodeTypes.CustomFunction, name: name.slice(1), params: [] };\n    }\n    return { type: MethodChainNodeTypes.Identifier, name };\n  };\n\n  return {\n    type: MethodChainNodeTypes.Chain,\n    links: [...parentChain.links, typeof appended === 'string' ? buildNode(appended) : appended],\n  };\n};\n\nexport const parseWithPartialOption = (\n  path: string,\n): { methodChain: Chain; partial: string; valid: boolean } => {\n  if (isValid(path)) {\n    const methodChain = parseMethodChain(path);\n\n    return {\n      methodChain: {\n        type: MethodChainNodeTypes.Chain,\n        links: methodChain.links.slice(0, methodChain.links.length - 1),\n      },\n      partial: last(methodChain.links)?.name || '',\n      valid: true,\n    };\n  }\n\n  const rawParse = (input: string): Chain => {\n    return normalizeChain(updatedParse(input, { strict: true }));\n  };\n\n  try {\n    if (path.endsWith('.')) {\n      return {\n        methodChain: rawParse(path.slice(0, -1)),\n        partial: '',\n        valid: true,\n      };\n    }\n\n    if (path.lastIndexOf('[') > path.lastIndexOf(']')) {\n      const partialString = path.slice(path.lastIndexOf('[') + 2);\n      const partialValue = partialString.endsWith(\"'\") ? partialString.slice(0, -1) : partialString;\n      return {\n        methodChain: rawParse(path.slice(0, path.lastIndexOf('['))),\n        partial: partialValue,\n        valid: true,\n      };\n    }\n  } catch {\n    /* empty */\n  }\n\n  return {\n    methodChain: EMPTY_METHOD_CHAIN,\n    partial: path,\n    valid: false,\n  };\n};\n\n// Check if the path can be parsed as legacy method chain format.\n// Normative means all the name parts are\n// 1. delimited by only dots and\n// 2. only contain alphanumeric characters, underscores, and hyphens.\nexport const pathIsNormative = (path: string): boolean => {\n  return path.split('.').every((part) => /^[a-zA-Z0-9_-]+$/.test(part));\n};\nexport const getSyntaxError = (): typeof UpdatedSyntaxError => UpdatedSyntaxError;\n\nexport const methodChainNodeToJsonSchema = (\n  node: StringNode | NumberNode | ArrayNode,\n): JsonSchema | null => {\n  if (node.type === MethodChainNodeTypes.String) {\n    return {\n      type: JsonSchemaTypes.String,\n    };\n  } else if (node.type === MethodChainNodeTypes.Number) {\n    return {\n      type: JsonSchemaTypes.Number,\n    };\n  } else if (node.type === MethodChainNodeTypes.Array) {\n    // Determine the items schema based on the first item type\n    // For simplicity, assume all items are the same type\n    if (node.items.length > 0) {\n      const firstItem = node.items[0];\n      const itemSchema: JsonSchema =\n        firstItem.type === MethodChainNodeTypes.String\n          ? { type: JsonSchemaTypes.String }\n          : { type: JsonSchemaTypes.Number };\n\n      return {\n        type: JsonSchemaTypes.Array,\n        items: itemSchema,\n      };\n    } else {\n      return {\n        type: JsonSchemaTypes.Array,\n        items: { type: JsonSchemaTypes.String },\n      };\n    }\n  }\n\n  return null;\n};\n"],"mappings":"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"}

package/dist/methodChainTypes-BVkTI8MX.d.mts

@@ -0,0 +1,23 @@
+import { c as ASTIdentifierNode, d as ASTNumberNode, m as ASTStringNode, n as ASTChain, o as ASTFunctionNode, r as ASTCustomFunctionNode, t as ASTArrayNode } from "./types-M-rsm1Km.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 { FunctionParamType as a, NumberNode as c, FunctionNode as i, StringNode as l, Chain as n, IdentifierNode as o, CustomFunctionNode as r, MethodChainNode as s, ArrayNode as t };
+//# sourceMappingURL=methodChainTypes-BVkTI8MX.d.mts.map

package/dist/mixins/focus.d.mts

@@ -1,4 +1,4 @@
-import { t as PseudoClassProps } from "../PseudoClassProps-CHtBNv8B.mjs";
+import { t as PseudoClassProps } from "../PseudoClassProps-BOVN6Etr.mjs";
 import * as _$styled_components0 from "styled-components";
 
 //#region mixins/focus.d.ts

package/dist/mixins/hoverable.d.mts

@@ -1,5 +1,5 @@
-import { o as Variant } from "../theme-CW6qlONZ.mjs";
-import { t as PseudoClassProps } from "../PseudoClassProps-CHtBNv8B.mjs";
+import { o as Variant } from "../theme-BB1B6Wkz.mjs";
+import { t as PseudoClassProps } from "../PseudoClassProps-BOVN6Etr.mjs";
 import * as _$styled_components0 from "styled-components";
 
 //#region mixins/hoverable.d.ts

package/dist/mixins/input.d.mts

@@ -1,2 +1,2 @@
-import { n as InputSizes, r as inputMixin, t as InputMixinProps } from "../input-DVJhMlxU.mjs";
+import { n as InputSizes, r as inputMixin, t as InputMixinProps } from "../input-DpHBIUpP.mjs";
 export { InputMixinProps, InputSizes, inputMixin as default };

package/dist/mixins/input.mjs

@@ -38,7 +38,10 @@ const inputMixin = css`
   }
 
   &${isDisabled} {
-    background: ${({ theme }) => semanticColor(theme, "InputSurfaceDisabled", theme.color.background.disabled)};
+    background: ${({ theme }) => {
+	const tokens = semanticTokens(theme);
+	return tokens ? withAlpha(tokens.InputSurfaceDisabled, tokens.Opacity65) : theme.color.background.disabled;
+}};
     border-color: ${({ theme }) => semanticColor(theme, "InputBorderDisabled", theme.color.border.disabled)};
     color: ${({ theme }) => semanticColor(theme, "FgDisabled", theme.color.text.disabled)};
     ::placeholder {
@@ -80,8 +83,9 @@ const inputMixin = css`
 	}
 }}
 
+  /* Validation borders are for enabled fields only. Disabled fields keep the
+     disabled border above, whose :disabled selector outranks this bare rule. */
   ${({ theme, hasError, hasWarning }) => {
-	const tokens = semanticTokens(theme);
 	if (hasError) {
 		const danger = semanticColor(theme, "BorderDanger", theme.color.variants.danger.default);
 		return css`
@@ -90,12 +94,6 @@ const inputMixin = css`
         &${isHovered}${isNotDisabled} {
           border-color: ${danger};
         }
-
-        ${tokens && css`
-          &${isDisabled} {
-            border-color: ${withAlpha(tokens.BorderDanger, tokens.Opacity65)};
-          }
-        `}
       `;
 	}
 	if (hasWarning) {
@@ -106,12 +104,6 @@ const inputMixin = css`
         &${isHovered}${isNotDisabled} {
           border-color: ${warning};
         }
-
-        ${tokens && css`
-          &${isDisabled} {
-            border-color: ${withAlpha(tokens.BorderWarning, tokens.Opacity65)};
-          }
-        `}
       `;
 	}
 	return css`

package/dist/mixins/input.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"input.mjs","names":[],"sources":["../../mixins/input.ts"],"sourcesContent":["import { css } from 'styled-components';\n\nimport { Color, Spacing, Typography } from '@persona/design-tokens';\nimport { withAlpha } from 'design-system/lib/color';\nimport { isDisabled, isHovered, isNotDisabled } from 'design-system/lib/pseudoClass';\nimport { semanticColor, semanticTokens } from 'design-system/lib/semanticColor';\nimport { focusOutlineControlled } from 'design-system/mixins/focus';\nimport { printMixins } from 'design-system/mixins/print';\nimport type ErrorProps from 'design-system/types/ErrorProps';\nimport type PseudoClassProps from 'design-system/types/PseudoClassProps';\nimport { TransitionDuration } from 'design-system/variables/transitions';\n\nexport type InputSizes = 'md' | 'sm';\n\nexport interface InputMixinProps extends ErrorProps, PseudoClassProps {\n  $size?: InputSizes;\n}\n\n/**\n * Provides input-like hover and focus outline effects. Can also be applied to\n * non-input elements (like divs) to give input-like styles.\n */\nconst inputMixin = css<InputMixinProps>`\n  background: ${({ theme }) =>\n    semanticColor(theme, 'InputSurfaceDefault', theme.color.background.primary)};\n  color: ${({ theme }) => semanticColor(theme, 'FgPrimary', theme.color.text.primary)};\n  border-width: 1px;\n  border-style: solid;\n  border-color: ${({ theme }) => semanticColor(theme, 'InputBorderDefault', theme.color.border.input)};\n  box-sizing: border-box;\n  border-radius: ${({ theme }) => theme.element.borderRadius};\n\n  width: 100%;\n  min-width: 0;\n\n  ${focusOutlineControlled}\n\n  text-decoration: none;\n  transition-duration: ${TransitionDuration.Fast};\n  transition-property: background-color, color, border-color, width, height;\n\n  /* Some input-likes like <select/> reduce opacity when disabled */\n  opacity: 1;\n\n  &::placeholder {\n    font-weight: ${({ theme }) => theme.text.paragraph.md.fontWeight};\n    color: ${({ theme }) => semanticColor(theme, 'FgSecondary', theme.color.text.tertiary)};\n  }\n\n  &${isDisabled} {\n    background: ${({ theme }) =>\n      semanticColor(theme, 'InputSurfaceDisabled', theme.color.background.disabled)};\n    border-color: ${({ theme }) =>\n      semanticColor(theme, 'InputBorderDisabled', theme.color.border.disabled)};\n    color: ${({ theme }) => semanticColor(theme, 'FgDisabled', theme.color.text.disabled)};\n    ::placeholder {\n      color: ${({ theme }) => semanticColor(theme, 'FgDisabled', theme.color.text.disabled)};\n    }\n  }\n\n  &${isHovered}${isNotDisabled} {\n    ${({ theme }) => {\n      const tokens = semanticTokens(theme);\n      return tokens\n        ? css`\n            background: ${tokens.InputSurfaceHover};\n            border-color: ${tokens.InputBorderHover};\n          `\n        : css`\n            border-color: ${theme.color.border.inputHover};\n          `;\n    }}\n  }\n\n  ${({ $size }) => {\n    switch ($size) {\n      default:\n      case 'md':\n        return css`\n          height: ${({ theme }) => theme.element.height.xs};\n          padding-top: ${Spacing[2]};\n          padding-right: ${Spacing[3]};\n          padding-bottom: ${Spacing[2]};\n          padding-left: ${Spacing[3]};\n          ${Typography.TextMedium};\n        `;\n      case 'sm':\n        return css`\n          height: 24px;\n          padding-top: ${Spacing[1]};\n          padding-right: ${Spacing[2]};\n          padding-bottom: ${Spacing[1]};\n          padding-left: ${Spacing[2]};\n          ${Typography.TextSmall};\n        `;\n    }\n  }}\n\n  ${({ theme, hasError, hasWarning }) => {\n    const tokens = semanticTokens(theme);\n\n    if (hasError) {\n      const danger = semanticColor(theme, 'BorderDanger', theme.color.variants.danger.default);\n      return css`\n        border-color: ${danger};\n\n        &${isHovered}${isNotDisabled} {\n          border-color: ${danger};\n        }\n\n        ${\n          tokens &&\n          css`\n          &${isDisabled} {\n            border-color: ${withAlpha(tokens.BorderDanger, tokens.Opacity65)};\n          }\n        `\n        }\n      `;\n    }\n\n    if (hasWarning) {\n      const warning = semanticColor(theme, 'BorderWarning', Color.CoreOrange700);\n      return css`\n        border-color: ${warning};\n\n        &${isHovered}${isNotDisabled} {\n          border-color: ${warning};\n        }\n\n        ${\n          tokens &&\n          css`\n          &${isDisabled} {\n            border-color: ${withAlpha(tokens.BorderWarning, tokens.Opacity65)};\n          }\n        `\n        }\n      `;\n    }\n\n    return css`\n      border-color: ${semanticColor(theme, 'InputBorderDefault', theme.color.border.input)};\n    `;\n  }}\n\n  ${printMixins.hide}\n`;\n\nexport default inputMixin;\n"],"mappings":";;;;;;;;;;;;;AAsBA,MAAM,aAAa,GAAoB;iBACtB,EAAE,YACf,cAAc,OAAO,uBAAuB,MAAM,MAAM,WAAW,QAAQ,CAAC;YACpE,EAAE,YAAY,cAAc,OAAO,aAAa,MAAM,MAAM,KAAK,QAAQ,CAAC;;;mBAGnE,EAAE,YAAY,cAAc,OAAO,sBAAsB,MAAM,MAAM,OAAO,MAAM,CAAC;;oBAElF,EAAE,YAAY,MAAM,QAAQ,aAAa;;;;;IAKzD,uBAAuB;;;iCAGsB;;;;;;;oBAO7B,EAAE,YAAY,MAAM,KAAK,UAAU,GAAG,WAAW;cACvD,EAAE,YAAY,cAAc,OAAO,eAAe,MAAM,MAAM,KAAK,SAAS,CAAC;;;KAGtF,WAAW;mBACG,EAAE,YACf,cAAc,OAAO,wBAAwB,MAAM,MAAM,WAAW,SAAS,CAAC;qBAC/D,EAAE,YACjB,cAAc,OAAO,uBAAuB,MAAM,MAAM,OAAO,SAAS,CAAC;cACjE,EAAE,YAAY,cAAc,OAAO,cAAc,MAAM,MAAM,KAAK,SAAS,CAAC;;gBAE1E,EAAE,YAAY,cAAc,OAAO,cAAc,MAAM,MAAM,KAAK,SAAS,CAAC;;;;KAIvF,YAAY,cAAc;OACxB,EAAE,YAAY;CACf,MAAM,SAAS,eAAe,MAAM;AACpC,QAAO,SACH,GAAG;0BACa,OAAO,kBAAkB;4BACvB,OAAO,iBAAiB;cAE1C,GAAG;4BACe,MAAM,MAAM,OAAO,WAAW;;EAEpD;;;KAGD,EAAE,YAAY;AACf,SAAQ,OAAR;EACE;EACA,KAAK,KACH,QAAO,GAAG;qBACG,EAAE,YAAY,MAAM,QAAQ,OAAO,GAAG;yBAClC,QAAQ,GAAG;2BACT,QAAQ,GAAG;4BACV,QAAQ,GAAG;0BACb,QAAQ,GAAG;YACzB,WAAW,WAAW;;EAE5B,KAAK,KACH,QAAO,GAAG;;yBAEO,QAAQ,GAAG;2BACT,QAAQ,GAAG;4BACV,QAAQ,GAAG;0BACb,QAAQ,GAAG;YACzB,WAAW,UAAU;;;EAG7B;;KAEC,EAAE,OAAO,UAAU,iBAAiB;CACrC,MAAM,SAAS,eAAe,MAAM;AAEpC,KAAI,UAAU;EACZ,MAAM,SAAS,cAAc,OAAO,gBAAgB,MAAM,MAAM,SAAS,OAAO,QAAQ;AACxF,SAAO,GAAG;wBACQ,OAAO;;WAEpB,YAAY,cAAc;0BACX,OAAO;;;UAIvB,UACA,GAAG;aACA,WAAW;4BACI,UAAU,OAAO,cAAc,OAAO,UAAU,CAAC;;UAGpE;;;AAIL,KAAI,YAAY;EACd,MAAM,UAAU,cAAc,OAAO,iBAAiB,MAAM,cAAc;AAC1E,SAAO,GAAG;wBACQ,QAAQ;;WAErB,YAAY,cAAc;0BACX,QAAQ;;;UAIxB,UACA,GAAG;aACA,WAAW;4BACI,UAAU,OAAO,eAAe,OAAO,UAAU,CAAC;;UAGrE;;;AAIL,QAAO,GAAG;sBACQ,cAAc,OAAO,sBAAsB,MAAM,MAAM,OAAO,MAAM,CAAC;;EAEvF;;IAEA,YAAY,KAAK"}
+{"version":3,"file":"input.mjs","names":[],"sources":["../../mixins/input.ts"],"sourcesContent":["import { css } from 'styled-components';\n\nimport { Color, Spacing, Typography } from '@persona/design-tokens';\nimport { withAlpha } from 'design-system/lib/color';\nimport { isDisabled, isHovered, isNotDisabled } from 'design-system/lib/pseudoClass';\nimport { semanticColor, semanticTokens } from 'design-system/lib/semanticColor';\nimport { focusOutlineControlled } from 'design-system/mixins/focus';\nimport { printMixins } from 'design-system/mixins/print';\nimport type ErrorProps from 'design-system/types/ErrorProps';\nimport type PseudoClassProps from 'design-system/types/PseudoClassProps';\nimport { TransitionDuration } from 'design-system/variables/transitions';\n\nexport type InputSizes = 'md' | 'sm';\n\nexport interface InputMixinProps extends ErrorProps, PseudoClassProps {\n  $size?: InputSizes;\n}\n\n/**\n * Provides input-like hover and focus outline effects. Can also be applied to\n * non-input elements (like divs) to give input-like styles.\n */\nconst inputMixin = css<InputMixinProps>`\n  background: ${({ theme }) =>\n    semanticColor(theme, 'InputSurfaceDefault', theme.color.background.primary)};\n  color: ${({ theme }) => semanticColor(theme, 'FgPrimary', theme.color.text.primary)};\n  border-width: 1px;\n  border-style: solid;\n  border-color: ${({ theme }) => semanticColor(theme, 'InputBorderDefault', theme.color.border.input)};\n  box-sizing: border-box;\n  border-radius: ${({ theme }) => theme.element.borderRadius};\n\n  width: 100%;\n  min-width: 0;\n\n  ${focusOutlineControlled}\n\n  text-decoration: none;\n  transition-duration: ${TransitionDuration.Fast};\n  transition-property: background-color, color, border-color, width, height;\n\n  /* Some input-likes like <select/> reduce opacity when disabled */\n  opacity: 1;\n\n  &::placeholder {\n    font-weight: ${({ theme }) => theme.text.paragraph.md.fontWeight};\n    color: ${({ theme }) => semanticColor(theme, 'FgSecondary', theme.color.text.tertiary)};\n  }\n\n  &${isDisabled} {\n    background: ${({ theme }) => {\n      const tokens = semanticTokens(theme);\n      return tokens\n        ? withAlpha(tokens.InputSurfaceDisabled, tokens.Opacity65)\n        : theme.color.background.disabled;\n    }};\n    border-color: ${({ theme }) =>\n      semanticColor(theme, 'InputBorderDisabled', theme.color.border.disabled)};\n    color: ${({ theme }) => semanticColor(theme, 'FgDisabled', theme.color.text.disabled)};\n    ::placeholder {\n      color: ${({ theme }) => semanticColor(theme, 'FgDisabled', theme.color.text.disabled)};\n    }\n  }\n\n  &${isHovered}${isNotDisabled} {\n    ${({ theme }) => {\n      const tokens = semanticTokens(theme);\n      return tokens\n        ? css`\n            background: ${tokens.InputSurfaceHover};\n            border-color: ${tokens.InputBorderHover};\n          `\n        : css`\n            border-color: ${theme.color.border.inputHover};\n          `;\n    }}\n  }\n\n  ${({ $size }) => {\n    switch ($size) {\n      default:\n      case 'md':\n        return css`\n          height: ${({ theme }) => theme.element.height.xs};\n          padding-top: ${Spacing[2]};\n          padding-right: ${Spacing[3]};\n          padding-bottom: ${Spacing[2]};\n          padding-left: ${Spacing[3]};\n          ${Typography.TextMedium};\n        `;\n      case 'sm':\n        return css`\n          height: 24px;\n          padding-top: ${Spacing[1]};\n          padding-right: ${Spacing[2]};\n          padding-bottom: ${Spacing[1]};\n          padding-left: ${Spacing[2]};\n          ${Typography.TextSmall};\n        `;\n    }\n  }}\n\n  /* Validation borders are for enabled fields only. Disabled fields keep the\n     disabled border above, whose :disabled selector outranks this bare rule. */\n  ${({ theme, hasError, hasWarning }) => {\n    if (hasError) {\n      const danger = semanticColor(theme, 'BorderDanger', theme.color.variants.danger.default);\n      return css`\n        border-color: ${danger};\n\n        &${isHovered}${isNotDisabled} {\n          border-color: ${danger};\n        }\n      `;\n    }\n\n    if (hasWarning) {\n      const warning = semanticColor(theme, 'BorderWarning', Color.CoreOrange700);\n      return css`\n        border-color: ${warning};\n\n        &${isHovered}${isNotDisabled} {\n          border-color: ${warning};\n        }\n      `;\n    }\n\n    return css`\n      border-color: ${semanticColor(theme, 'InputBorderDefault', theme.color.border.input)};\n    `;\n  }}\n\n  ${printMixins.hide}\n`;\n\nexport default inputMixin;\n"],"mappings":";;;;;;;;;;;;;AAsBA,MAAM,aAAa,GAAoB;iBACtB,EAAE,YACf,cAAc,OAAO,uBAAuB,MAAM,MAAM,WAAW,QAAQ,CAAC;YACpE,EAAE,YAAY,cAAc,OAAO,aAAa,MAAM,MAAM,KAAK,QAAQ,CAAC;;;mBAGnE,EAAE,YAAY,cAAc,OAAO,sBAAsB,MAAM,MAAM,OAAO,MAAM,CAAC;;oBAElF,EAAE,YAAY,MAAM,QAAQ,aAAa;;;;;IAKzD,uBAAuB;;;iCAGsB;;;;;;;oBAO7B,EAAE,YAAY,MAAM,KAAK,UAAU,GAAG,WAAW;cACvD,EAAE,YAAY,cAAc,OAAO,eAAe,MAAM,MAAM,KAAK,SAAS,CAAC;;;KAGtF,WAAW;mBACG,EAAE,YAAY;CAC3B,MAAM,SAAS,eAAe,MAAM;AACpC,QAAO,SACH,UAAU,OAAO,sBAAsB,OAAO,UAAU,GACxD,MAAM,MAAM,WAAW;EAC3B;qBACe,EAAE,YACjB,cAAc,OAAO,uBAAuB,MAAM,MAAM,OAAO,SAAS,CAAC;cACjE,EAAE,YAAY,cAAc,OAAO,cAAc,MAAM,MAAM,KAAK,SAAS,CAAC;;gBAE1E,EAAE,YAAY,cAAc,OAAO,cAAc,MAAM,MAAM,KAAK,SAAS,CAAC;;;;KAIvF,YAAY,cAAc;OACxB,EAAE,YAAY;CACf,MAAM,SAAS,eAAe,MAAM;AACpC,QAAO,SACH,GAAG;0BACa,OAAO,kBAAkB;4BACvB,OAAO,iBAAiB;cAE1C,GAAG;4BACe,MAAM,MAAM,OAAO,WAAW;;EAEpD;;;KAGD,EAAE,YAAY;AACf,SAAQ,OAAR;EACE;EACA,KAAK,KACH,QAAO,GAAG;qBACG,EAAE,YAAY,MAAM,QAAQ,OAAO,GAAG;yBAClC,QAAQ,GAAG;2BACT,QAAQ,GAAG;4BACV,QAAQ,GAAG;0BACb,QAAQ,GAAG;YACzB,WAAW,WAAW;;EAE5B,KAAK,KACH,QAAO,GAAG;;yBAEO,QAAQ,GAAG;2BACT,QAAQ,GAAG;4BACV,QAAQ,GAAG;0BACb,QAAQ,GAAG;YACzB,WAAW,UAAU;;;EAG7B;;;;KAIC,EAAE,OAAO,UAAU,iBAAiB;AACrC,KAAI,UAAU;EACZ,MAAM,SAAS,cAAc,OAAO,gBAAgB,MAAM,MAAM,SAAS,OAAO,QAAQ;AACxF,SAAO,GAAG;wBACQ,OAAO;;WAEpB,YAAY,cAAc;0BACX,OAAO;;;;AAK7B,KAAI,YAAY;EACd,MAAM,UAAU,cAAc,OAAO,iBAAiB,MAAM,cAAc;AAC1E,SAAO,GAAG;wBACQ,QAAQ;;WAErB,YAAY,cAAc;0BACX,QAAQ;;;;AAK9B,QAAO,GAAG;sBACQ,cAAc,OAAO,sBAAsB,MAAM,MAAM,OAAO,MAAM,CAAC;;EAEvF;;IAEA,YAAY,KAAK"}

package/dist/mixins/menuItem.d.mts

@@ -1,5 +1,5 @@
-import { o as Variant } from "../theme-CW6qlONZ.mjs";
-import { t as PseudoClassProps } from "../PseudoClassProps-CHtBNv8B.mjs";
+import { o as Variant } from "../theme-BB1B6Wkz.mjs";
+import { t as PseudoClassProps } from "../PseudoClassProps-BOVN6Etr.mjs";
 import * as _$styled_components0 from "styled-components";
 
 //#region mixins/menuItem.d.ts

package/dist/mixins/scrollbar.d.mts

@@ -0,0 +1,10 @@
+import { t as MaybeSemanticTheme } from "../semanticColor-Bg0H3RUL.mjs";
+import * as _$styled_components0 from "styled-components";
+
+//#region mixins/scrollbar.d.ts
+declare const semanticScrollbar: _$styled_components0.FlattenInterpolation<_$styled_components0.ThemedStyledProps<{
+  theme?: MaybeSemanticTheme;
+}, any>>;
+//#endregion
+export { semanticScrollbar };
+//# sourceMappingURL=scrollbar.d.mts.map

package/dist/mixins/scrollbar.mjs

@@ -0,0 +1,31 @@
+import { r as css } from "../styledComponentsInterop-NxwFjeA4.mjs";
+import { semanticOnly } from "../lib/semanticColor.mjs";
+import { Spacing } from "@persona/design-tokens";
+//#region mixins/scrollbar.ts
+const semanticScrollbar = css`
+  ${semanticOnly((tokens) => `
+      scrollbar-color: ${tokens.BorderDefault} transparent;
+
+      &::-webkit-scrollbar {
+        width: ${Spacing[2]};
+        height: ${Spacing[2]};
+      }
+
+      &::-webkit-scrollbar-track {
+        background: transparent;
+      }
+
+      &::-webkit-scrollbar-thumb {
+        background: ${tokens.BorderDefault};
+        border-radius: ${Spacing[2]};
+      }
+
+      &::-webkit-scrollbar-thumb:hover {
+        background: ${tokens.BorderHover};
+      }
+    `)}
+`;
+//#endregion
+export { semanticScrollbar };
+
+//# sourceMappingURL=scrollbar.mjs.map

package/dist/mixins/scrollbar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollbar.mjs","names":[],"sources":["../../mixins/scrollbar.ts"],"sourcesContent":["import { css } from 'styled-components';\n\nimport { Spacing } from '@persona/design-tokens';\nimport { semanticOnly } from 'design-system/lib/semanticColor';\n\n// Legacy themes keep the browser scrollbar. These colors exist only once semantic tokens are installed.\nexport const semanticScrollbar = css`\n  ${semanticOnly(\n    (tokens) => `\n      scrollbar-color: ${tokens.BorderDefault} transparent;\n\n      &::-webkit-scrollbar {\n        width: ${Spacing[2]};\n        height: ${Spacing[2]};\n      }\n\n      &::-webkit-scrollbar-track {\n        background: transparent;\n      }\n\n      &::-webkit-scrollbar-thumb {\n        background: ${tokens.BorderDefault};\n        border-radius: ${Spacing[2]};\n      }\n\n      &::-webkit-scrollbar-thumb:hover {\n        background: ${tokens.BorderHover};\n      }\n    `,\n  )}\n`;\n"],"mappings":";;;;AAMA,MAAa,oBAAoB,GAAG;IAChC,cACC,WAAW;yBACS,OAAO,cAAc;;;iBAG7B,QAAQ,GAAG;kBACV,QAAQ,GAAG;;;;;;;;sBAQP,OAAO,cAAc;yBAClB,QAAQ,GAAG;;;;sBAId,OAAO,YAAY;;MAGtC,CAAC"}

package/dist/mixins/text.d.mts

@@ -1,2 +1,2 @@
-import { a as displayMixins, c as paragraphMixins, i as ParagraphSize, n as HeadingSize, o as fontFamilyMixin, r as ParagraphMixinSize, s as headingMixins, t as DisplaySize } from "../text-CxIup7HJ.mjs";
+import { a as displayMixins, c as paragraphMixins, i as ParagraphSize, n as HeadingSize, o as fontFamilyMixin, r as ParagraphMixinSize, s as headingMixins, t as DisplaySize } from "../text-Iw9DKpbZ.mjs";
 export { DisplaySize, HeadingSize, ParagraphMixinSize, ParagraphSize, displayMixins, fontFamilyMixin, headingMixins, paragraphMixins };

package/dist/{operators-1_jTgYRX.d.mts → operators-BG82-g3M.d.mts}

@@ -1,4 +1,4 @@
-import { a as FilterField, c as FilterOperator, l as FilterRule, r as DateRangeFilterValue, s as FilterFieldType, u as FilterRuleValue } from "./types-BEjWTkZV.mjs";
+import { a as FilterField, c as FilterOperator, l as FilterRule, r as DateRangeFilterValue, s as FilterFieldType, u as FilterRuleValue } from "./types-Dy3lZv9z.mjs";
 
 //#region components/DataTable/TableControls/FiltersV2/operators.d.ts
 declare function getOperatorsForType(type: FilterFieldType): ReadonlyArray<FilterOperator>;
@@ -23,6 +23,12 @@ declare function isValuelessOperator(operator: FilterOperator): boolean;
  * where the wire expects a day string.
  */
 declare function carriesDateRange(operator: FilterOperator, fieldType?: FilterFieldType): boolean;
+/**
+ * Whether a rule's value control edits minute-precision date-times: the bar
+ * and field both opt in, and the value is a range or a before/after instant
+ * (`date` + `is` stays a whole calendar day).
+ */
+declare function isMinutePrecisionDate(field: Pick<FilterField, 'type' | 'timeGranularity'>, operator: FilterOperator, dateTimesEnabled: boolean): boolean;
 declare function isRangeOperator(operator: FilterOperator): boolean;
 /**
  * Whether `value` carries both endpoints of a range. Shared by the pill,
@@ -67,5 +73,5 @@ declare function emptyValueForRule(field: Pick<FilterField, 'type'>, operator: F
  */
 declare function reconcileValueForOperator(field: Pick<FilterField, 'type'>, nextOperator: FilterOperator, previousOperator: FilterOperator, value: FilterRuleValue): FilterRuleValue;
 //#endregion
-export { getDefaultOperatorForType as a, getOperatorsForType as c, isValuelessOperator as d, reconcileValueForOperator as f, fieldHasMultipleOperators as i, isCompleteDateRange as l, emptyValueForFieldType as n, getOperatorLabel as o, withValue as p, emptyValueForRule as r, getOperatorsForField as s, carriesDateRange as t, isRangeOperator as u };
-//# sourceMappingURL=operators-1_jTgYRX.d.mts.map
+export { getDefaultOperatorForType as a, getOperatorsForType as c, isRangeOperator as d, isValuelessOperator as f, fieldHasMultipleOperators as i, isCompleteDateRange as l, withValue as m, emptyValueForFieldType as n, getOperatorLabel as o, reconcileValueForOperator as p, emptyValueForRule as r, getOperatorsForField as s, carriesDateRange as t, isMinutePrecisionDate as u };
+//# sourceMappingURL=operators-BG82-g3M.d.mts.map

package/dist/operators.d.mts

@@ -1,2 +1,2 @@
-import { a as getDefaultOperatorForType, c as getOperatorsForType, d as isValuelessOperator, f as reconcileValueForOperator, i as fieldHasMultipleOperators, l as isCompleteDateRange, n as emptyValueForFieldType, o as getOperatorLabel, p as withValue, r as emptyValueForRule, s as getOperatorsForField, t as carriesDateRange, u as isRangeOperator } from "./operators-1_jTgYRX.mjs";
-export { carriesDateRange, emptyValueForFieldType, emptyValueForRule, fieldHasMultipleOperators, getDefaultOperatorForType, getOperatorLabel, getOperatorsForField, getOperatorsForType, isCompleteDateRange, isRangeOperator, isValuelessOperator, reconcileValueForOperator, withValue };
+import { a as getDefaultOperatorForType, c as getOperatorsForType, d as isRangeOperator, f as isValuelessOperator, i as fieldHasMultipleOperators, l as isCompleteDateRange, m as withValue, n as emptyValueForFieldType, o as getOperatorLabel, p as reconcileValueForOperator, r as emptyValueForRule, s as getOperatorsForField, t as carriesDateRange, u as isMinutePrecisionDate } from "./operators-BG82-g3M.mjs";
+export { carriesDateRange, emptyValueForFieldType, emptyValueForRule, fieldHasMultipleOperators, getDefaultOperatorForType, getOperatorLabel, getOperatorsForField, getOperatorsForType, isCompleteDateRange, isMinutePrecisionDate, isRangeOperator, isValuelessOperator, reconcileValueForOperator, withValue };