@plasmicpkgs/react-aria 0.0.42 → 0.0.44

package/dist/registerButton.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import type { ButtonProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const BUTTON_INTERACTION_VARIANTS: ("hovered" | "pressed" | "focused" | "focusVisible" | "disabled")[];
+declare const BUTTON_INTERACTION_VARIANTS: ("disabled" | "hovered" | "pressed" | "focused" | "focusVisible")[];
 interface BaseButtonProps extends ButtonProps {
     children: React.ReactNode;
     resetsForm?: boolean;

package/dist/registerCheckbox.d.ts

@@ -2,11 +2,10 @@ import { PlasmicElement } from "@plasmicapp/host";
 import React from "react";
 import type { CheckboxProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const CHECKBOX_INTERACTION_VARIANTS: ("hovered" | "pressed" | "focused" | "focusVisible" | "selected" | "readonly" | "disabled" | "indeterminate")[];
-interface BaseCheckboxProps extends CheckboxProps {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+declare const CHECKBOX_INTERACTION_VARIANTS: ("disabled" | "readonly" | "hovered" | "pressed" | "focused" | "focusVisible" | "selected" | "indeterminate")[];
+interface BaseCheckboxProps extends CheckboxProps, HasControlContextData {
     children: React.ReactNode;
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
     updateInteractionVariant?: UpdateInteractionVariant<typeof CHECKBOX_INTERACTION_VARIANTS>;
 }
 export declare function BaseCheckbox(props: BaseCheckboxProps): React.JSX.Element;

package/dist/registerCheckboxGroup.d.ts

@@ -2,9 +2,9 @@ import React from "react";
 import type { CheckboxGroupProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const CHECKBOX_GROUP_INTERACTION_VARIANTS: ("readonly" | "disabled")[];
+declare const CHECKBOX_GROUP_INTERACTION_VARIANTS: ("disabled" | "readonly")[];
 export interface BaseCheckboxGroupProps extends CheckboxGroupProps {
-    children: React.ReactNode;
+    children?: React.ReactNode;
     updateInteractionVariant?: UpdateInteractionVariant<typeof CHECKBOX_GROUP_INTERACTION_VARIANTS>;
 }
 export declare function BaseCheckboxGroup(props: BaseCheckboxGroupProps): React.JSX.Element;

package/dist/registerInput.d.ts

@@ -1,12 +1,19 @@
-import React from "react";
+import React, { ChangeEvent } from "react";
 import type { InputProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const INPUT_INTERACTION_VARIANTS: ("hovered" | "focused" | "disabled")[];
-export interface BaseInputProps extends InputProps {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+declare const INPUT_INTERACTION_VARIANTS: ("disabled" | "hovered" | "focused")[];
+export interface BaseInputProps extends Omit<InputProps, "autoComplete">, HasControlContextData {
     updateInteractionVariant?: UpdateInteractionVariant<typeof INPUT_INTERACTION_VARIANTS>;
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
+    autoComplete?: string[];
 }
+export declare const inputHelpers: {
+    states: {
+        value: {
+            onChangeArgsToValue: (e: ChangeEvent<HTMLInputElement>) => string;
+        };
+    };
+};
 export declare function BaseInput(props: BaseInputProps): React.JSX.Element;
 export declare const INPUT_COMPONENT_NAME: string;
 export declare function registerInput(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseInput>): void;

package/dist/registerListBox.d.ts

@@ -1,12 +1,11 @@
 import React from "react";
 import { ListBox } from "react-aria-components";
 import { HasOptions } from "./option-utils";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-export interface BaseListBoxProps extends React.ComponentProps<typeof ListBox>, HasOptions<any> {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+export interface BaseListBoxProps extends React.ComponentProps<typeof ListBox>, HasOptions<any>, HasControlContextData {
     renderItem?: (item: any) => React.ReactNode;
     renderSection?: (section: any) => React.ReactNode;
     getItemType?: (thing: any) => "item" | "section";
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
 }
 export declare function BaseListBox(props: BaseListBoxProps): React.JSX.Element;
 export declare const LIST_BOX_COMPONENT_NAME: string;

package/dist/registerModal.d.ts

@@ -1,11 +1,10 @@
 import React from "react";
 import { ModalOverlayProps } from "react-aria-components";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-export interface BaseModalProps extends ModalOverlayProps {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+export interface BaseModalProps extends ModalOverlayProps, HasControlContextData {
     heading: React.ReactNode;
     modalOverlayClass: string;
     onOpenChange(isOpen: boolean): void;
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
 }
 export interface BaseModalActions {
     close(): void;

package/dist/registerPopover.d.ts

@@ -1,17 +1,15 @@
 import { PlasmicElement } from "@plasmicapp/host";
 import React from "react";
 import { Popover } from "react-aria-components";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-interface PopoverControlContextData extends BaseControlContextData {
-    isInsideSelect: boolean;
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+export interface PopoverControlContextData {
+    defaultShouldFlip?: boolean;
 }
-export interface BasePopoverProps extends React.ComponentProps<typeof Popover> {
+export interface BasePopoverProps extends React.ComponentProps<typeof Popover>, HasControlContextData<PopoverControlContextData> {
     className?: string;
     resetClassName?: string;
-    setControlContextData?: (ctxData: PopoverControlContextData) => void;
 }
 export declare function BasePopover(props: BasePopoverProps): React.JSX.Element;
 export declare const POPOVER_COMPONENT_NAME: string;
 export declare const POPOVER_ARROW_IMG: PlasmicElement;
 export declare function registerPopover(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BasePopover>): void;
-export {};

package/dist/registerRadio.d.ts

@@ -2,12 +2,10 @@ import { PlasmicElement } from "@plasmicapp/host";
 import React from "react";
 import type { RadioProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const RADIO_INTERACTION_VARIANTS: ("hovered" | "pressed" | "focused" | "focusVisible" | "selected" | "readonly" | "disabled")[];
-export interface BaseRadioProps extends RadioProps {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+declare const RADIO_INTERACTION_VARIANTS: ("disabled" | "readonly" | "hovered" | "pressed" | "focused" | "focusVisible" | "selected")[];
+export interface BaseRadioProps extends RadioProps, HasControlContextData {
     children: React.ReactNode;
-    isSelected: boolean;
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
     updateInteractionVariant?: UpdateInteractionVariant<typeof RADIO_INTERACTION_VARIANTS>;
 }
 export declare function BaseRadio(props: BaseRadioProps): React.JSX.Element;

package/dist/registerRadioGroup.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import type { RadioGroupProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const RADIO_GROUP_INTERACTION_VARIANTS: ("readonly" | "disabled")[];
+declare const RADIO_GROUP_INTERACTION_VARIANTS: ("disabled" | "readonly")[];
 export interface BaseRadioGroupProps extends RadioGroupProps {
     children: React.ReactNode;
     updateInteractionVariant?: UpdateInteractionVariant<typeof RADIO_GROUP_INTERACTION_VARIANTS>;

package/dist/registerSlider.d.ts

@@ -2,28 +2,11 @@ import React from "react";
 import { type SliderProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-export declare const SLIDER_COMPONENT_NAME: string;
 declare const SLIDER_INTERACTION_VARIANTS: "disabled"[];
-export interface BaseSliderProps extends Omit<SliderProps<number | number[]>, "onChange"> {
-    name?: string;
-    autoFocus?: boolean;
-    isMultiValue?: boolean;
-    range?: number[];
-    defaultRange?: number[];
+export interface BaseSliderProps<T extends number | number[]> extends SliderProps<T> {
     children?: React.ReactNode;
-    onChange?: (value: number | number[], isMultiValue?: boolean) => void;
     updateInteractionVariant?: UpdateInteractionVariant<typeof SLIDER_INTERACTION_VARIANTS>;
 }
-export declare const sliderHelpers: {
-    states: {
-        range: {
-            onChangeArgsToValue: (value: number[], isMultiValue: boolean) => number[] | undefined;
-        };
-        value: {
-            onChangeArgsToValue: (value: number, isMultiValue: boolean) => any;
-        };
-    };
-};
-export declare function BaseSlider(props: BaseSliderProps): React.JSX.Element;
-export declare function registerSlider(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSlider>): void;
+export declare function BaseSlider<T extends number | number[]>(props: BaseSliderProps<T>): React.JSX.Element;
+export declare function registerSlider(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSlider<number>>): void;
 export {};

package/dist/registerSliderOutput.d.ts

@@ -9,5 +9,5 @@ export interface BaseSliderOutputProps extends React.ComponentProps<typeof Slide
 }
 export declare function BaseSliderOutput(props: BaseSliderOutputProps): React.JSX.Element;
 export declare const SLIDER_OUTPUT_COMPONENT_NAME: string;
-export declare function registerSliderOutput(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderOutput>): void;
+export declare function registerSliderOutput(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderOutput>): import("@plasmicapp/host").CodeComponentMeta<BaseSliderOutputProps>;
 export {};

package/dist/registerSliderThumb.d.ts

@@ -2,12 +2,12 @@ import React from "react";
 import { SliderThumb } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const SLIDER_THUMB_INTERACTION_VARIANTS: ("hovered" | "focused" | "focusVisible" | "dragging" | "disabled")[];
-interface BaseSliderThumbProps extends React.ComponentProps<typeof SliderThumb> {
+declare const SLIDER_THUMB_INTERACTION_VARIANTS: ("disabled" | "hovered" | "focused" | "focusVisible" | "dragging")[];
+export interface BaseSliderThumbProps extends React.ComponentProps<typeof SliderThumb> {
     advanced?: boolean;
     updateInteractionVariant?: UpdateInteractionVariant<typeof SLIDER_THUMB_INTERACTION_VARIANTS>;
 }
 export declare function BaseSliderThumb({ children, advanced, updateInteractionVariant, ...rest }: BaseSliderThumbProps): React.JSX.Element;
 export declare const SLIDER_THUMB_COMPONENT_NAME: string;
-export declare function registerSliderThumb(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderThumb>): void;
+export declare function registerSliderThumb(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderThumb>): import("@plasmicapp/host").CodeComponentMeta<BaseSliderThumbProps>;
 export {};

package/dist/registerSliderTrack.d.ts

@@ -1,6 +1,8 @@
+import { CodeComponentMeta } from "@plasmicapp/host";
 import React from "react";
 import { SliderTrack } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
+import { BaseSliderThumbProps } from "./registerSliderThumb";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
 declare const SLIDER_TRACK_INTERACTION_VARIANTS: "hovered"[];
 export interface BaseSliderTrackProps extends React.ComponentProps<typeof SliderTrack> {
@@ -10,5 +12,5 @@ export interface BaseSliderTrackProps extends React.ComponentProps<typeof Slider
 }
 export declare function BaseSliderTrack(props: BaseSliderTrackProps): React.JSX.Element;
 export declare const SLIDER_TRACK_COMPONENT_NAME: string;
-export declare function registerSliderTrack(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderTrack>): void;
+export declare function registerSliderTrack(sliderThumbMeta: CodeComponentMeta<BaseSliderThumbProps>, loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseSliderTrack>): CodeComponentMeta<BaseSliderTrackProps>;
 export {};

package/dist/registerSwitch.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import type { SwitchProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const SWITCH_INTERACTION_VARIANTS: ("hovered" | "pressed" | "focused" | "focusVisible" | "selected" | "readonly" | "disabled")[];
+declare const SWITCH_INTERACTION_VARIANTS: ("disabled" | "readonly" | "hovered" | "pressed" | "focused" | "focusVisible" | "selected")[];
 interface BaseSwitchProps extends SwitchProps {
     children: React.ReactNode;
     updateInteractionVariant?: UpdateInteractionVariant<typeof SWITCH_INTERACTION_VARIANTS>;

package/dist/registerTextArea.d.ts

@@ -1,12 +1,18 @@
-import React from "react";
+import React, { ChangeEvent } from "react";
 import type { TextAreaProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
-import { BaseControlContextData, CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const TEXTAREA_INTERACTION_VARIANTS: ("hovered" | "focused" | "disabled")[];
-export interface BaseTextAreaProps extends TextAreaProps {
+import { CodeComponentMetaOverrides, HasControlContextData, Registerable } from "./utils";
+declare const TEXTAREA_INTERACTION_VARIANTS: ("disabled" | "hovered" | "focused")[];
+export interface BaseTextAreaProps extends TextAreaProps, HasControlContextData {
     updateInteractionVariant?: UpdateInteractionVariant<typeof TEXTAREA_INTERACTION_VARIANTS>;
-    setControlContextData?: (ctxData: BaseControlContextData) => void;
 }
+export declare const inputHelpers: {
+    states: {
+        value: {
+            onChangeArgsToValue: (e: ChangeEvent<HTMLInputElement>) => string;
+        };
+    };
+};
 export declare function BaseTextArea(props: BaseTextAreaProps): React.JSX.Element;
 export declare function registerTextArea(loader?: Registerable, overrides?: CodeComponentMetaOverrides<typeof BaseTextArea>): void;
 export {};

package/dist/registerTextField.d.ts

@@ -2,13 +2,13 @@ import React, { ReactNode } from "react";
 import type { InputProps, TextFieldProps } from "react-aria-components";
 import { UpdateInteractionVariant } from "./interaction-variant-utils";
 import { CodeComponentMetaOverrides, Registerable } from "./utils";
-declare const TEXT_FIELD_INTERACTION_VARIANTS: ("readonly" | "disabled")[];
-export interface BaseTextFieldProps extends TextFieldProps {
+declare const TEXT_FIELD_INTERACTION_VARIANTS: ("disabled" | "readonly")[];
+export interface BaseTextFieldProps extends Omit<TextFieldProps, "autoComplete"> {
     label?: ReactNode;
     description?: ReactNode;
-    enableAutoComplete?: boolean;
     multiline?: boolean;
     inputProps?: InputProps;
+    autoComplete?: string[];
     children: ReactNode;
     updateInteractionVariant?: UpdateInteractionVariant<typeof TEXT_FIELD_INTERACTION_VARIANTS>;
 }

package/dist/utils.d.ts

@@ -1,8 +1,14 @@
 import type { CodeComponentMeta } from "@plasmicapp/host";
 import registerComponent from "@plasmicapp/host/registerComponent";
 import React from "react";
+export type HasControlContextData<T = BaseControlContextData> = {
+    setControlContextData?: (ctxData: T) => void;
+};
 export type BaseControlContextData = {
-    isStandalone: boolean;
+    parent?: {
+        isDisabled?: boolean;
+        isReadOnly?: boolean;
+    };
 };
 export type Registerable = {
     registerComponent: typeof registerComponent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmicpkgs/react-aria",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "Plasmic registration calls for react-aria based components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -74,5 +74,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "94d5603125aac87b0d1952dad0241fba1a6be371"
+  "gitHead": "485bcdc340f3027b149e373e6b622a472982eb90"
 }

package/skinny/common-96be13c3.esm.js

@@ -0,0 +1,341 @@
+import { i as isDefined } from './utils-a1785802.esm.js';
+
+function hasParent(_props, ctx) {
+  return isDefined(ctx == null ? void 0 : ctx.parent) === true;
+}
+function isParentReadOnly(_props, ctx) {
+  var _a;
+  return ((_a = ctx == null ? void 0 : ctx.parent) == null ? void 0 : _a.isReadOnly) === true;
+}
+function isParentDisabled(_props, ctx) {
+  var _a;
+  return ((_a = ctx == null ? void 0 : ctx.parent) == null ? void 0 : _a.isDisabled) === true;
+}
+function resolveAutoComplete(autoCompleteProp) {
+  if (typeof autoCompleteProp === "string") {
+    return autoCompleteProp;
+  }
+  if (!autoCompleteProp || !Array.isArray(autoCompleteProp) || autoCompleteProp.includes("off")) {
+    return void 0;
+  }
+  if (autoCompleteProp.includes("off")) {
+    return "off";
+  }
+  if (autoCompleteProp.includes("on") && autoCompleteProp.length === 1) {
+    return "on";
+  }
+  return autoCompleteProp.filter((x) => x !== "on").join(" ");
+}
+function createNameProp() {
+  return {
+    type: "string",
+    description: "Name for this field if it is part of a form",
+    hidden: hasParent,
+    advanced: true
+  };
+}
+function createDisabledProp(componentName) {
+  return {
+    displayName: "Disabled",
+    type: "boolean",
+    description: `Whether the ${componentName} is read-only and unfocusable`,
+    defaultValueHint: false,
+    hidden: isParentDisabled
+  };
+}
+function createReadOnlyProp(componentName) {
+  return {
+    displayName: "Read only",
+    type: "boolean",
+    description: `Whether the value of this ${componentName} can be changed by the user. Unlike disabled, read-only does not prevent the user from interacting with the component (such as focus).`,
+    defaultValueHint: false,
+    advanced: true,
+    hidden: isParentReadOnly
+  };
+}
+function createRequiredProp(componentName) {
+  return {
+    displayName: "Required",
+    type: "boolean",
+    description: `Whether user input is required on the ${componentName} before form submission.`,
+    defaultValueHint: false,
+    advanced: true,
+    hidden: hasParent
+  };
+}
+function createAutoFocusProp(componentName) {
+  return {
+    type: "boolean",
+    description: `Whether the ${componentName} should be focused when rendered`,
+    defaultValueHint: false,
+    advanced: true,
+    hidden: hasParent
+  };
+}
+function createAriaLabelProp(componentName) {
+  return {
+    type: "string",
+    displayName: "Aria Label",
+    description: `Label for this ${componentName}, if no visible label is used, to identify the element to assistive technology`,
+    advanced: true,
+    hidden: hasParent
+  };
+}
+function createChildrenProp() {
+  return {
+    type: "slot",
+    mergeWithParent: true
+  };
+}
+function getCommonProps(componentName, propNames) {
+  const commonProps = {
+    name: createNameProp(),
+    disabled: createDisabledProp(componentName),
+    isDisabled: createDisabledProp(componentName),
+    readOnly: createReadOnlyProp(componentName),
+    isReadOnly: createReadOnlyProp(componentName),
+    autoFocus: createAutoFocusProp(componentName),
+    "aria-label": createAriaLabelProp(componentName),
+    required: createRequiredProp(componentName),
+    isRequired: createRequiredProp(componentName),
+    children: createChildrenProp(),
+    // NOTE: The following props are only applicable to inputs, textareas, and text fields
+    value: {
+      type: "string",
+      editOnly: true,
+      displayName: "Default Value",
+      uncontrolledProp: "defaultValue",
+      description: `The default value of the ${componentName}`,
+      hidden: hasParent
+    },
+    maxLength: {
+      type: "number",
+      description: "The maximum number of characters supported by the input",
+      advanced: true,
+      hidden: hasParent
+    },
+    minLength: {
+      type: "number",
+      description: "The minimum number of characters supported by the input",
+      advanced: true,
+      hidden: hasParent
+    },
+    pattern: {
+      type: "string",
+      description: "Regex pattern that the value of the input must match to be valid",
+      helpText: "For more information about writing Regular Expressions (regex), check out https://regexr.com/",
+      validator: (value) => {
+        try {
+          new RegExp(value);
+          return true;
+        } catch (error) {
+          return "Invalid Regex";
+        }
+      },
+      advanced: true,
+      hidden: hasParent
+    },
+    type: {
+      type: "choice",
+      defaultValueHint: "text",
+      options: ["text", "search", "url", "tel", "email", "password"],
+      description: "The type of data that an input field is expected to handle. It influences the input's behavior, validation, and the kind of interface provided to the user.",
+      advanced: true,
+      hidden: hasParent
+    },
+    inputMode: {
+      type: "choice",
+      description: "hint to browsers as to the type of virtual keyboard configuration to use when editing this element or its contents.",
+      options: [
+        "none",
+        "text",
+        "tel",
+        "url",
+        "email",
+        "numeric",
+        "decimal",
+        "search"
+      ],
+      hidden: hasParent
+    },
+    autoComplete: {
+      type: "choice",
+      advanced: true,
+      multiSelect: true,
+      hidden: hasParent,
+      description: "Guidance as to the type of data expected in the field",
+      helpText: "For explanations on what each of the values mean, check https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values",
+      options: [
+        "on",
+        "off",
+        "name",
+        "honorific-prefix",
+        "given-name",
+        "additional-name",
+        "family-name",
+        "honorific-suffix",
+        "nickname",
+        "email",
+        "username",
+        "new-password",
+        "current-password",
+        "one-time-code",
+        "organization-title",
+        "organization",
+        "street-address",
+        "shipping",
+        "billing",
+        "address-line1",
+        "address-line2",
+        "address-line3",
+        "address-level4",
+        "address-level3",
+        "address-level2",
+        "address-level1",
+        "country",
+        "country-name",
+        "postal-code",
+        "cc-name",
+        "cc-given-name",
+        "cc-additional-name",
+        "cc-family-name",
+        "cc-number",
+        "cc-exp",
+        "cc-exp-month",
+        "cc-exp-year",
+        "cc-csc",
+        "cc-type",
+        "transaction-currency",
+        "transaction-amount",
+        "language",
+        "bday",
+        "bday-day",
+        "bday-month",
+        "bday-year",
+        "sex",
+        "tel",
+        "tel-country-code",
+        "tel-national",
+        "tel-area-code",
+        "tel-local",
+        "tel-local-suffix",
+        "tel-local-prefix",
+        "tel-extension",
+        "impp",
+        "url",
+        "photo",
+        "webauthn"
+      ]
+    },
+    validationBehavior: {
+      type: "choice",
+      options: ["native", "aria"],
+      description: "Whether to use native HTML form validation to prevent form submission when the value is missing or invalid, or mark the field as required or invalid via ARIA.",
+      defaultValueHint: "native",
+      advanced: true,
+      hidden: hasParent
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [{ name: "value", type: "string" }],
+      hidden: hasParent
+    },
+    onFocus: {
+      type: "eventHandler",
+      argTypes: [{ name: "focusEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onBlur: {
+      type: "eventHandler",
+      argTypes: [{ name: "focusEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onFocusChange: {
+      type: "eventHandler",
+      argTypes: [{ name: "isFocused", type: "boolean" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onKeyDown: {
+      type: "eventHandler",
+      argTypes: [{ name: "keyboardEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onKeyUp: {
+      type: "eventHandler",
+      argTypes: [{ name: "keyboardEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onCopy: {
+      type: "eventHandler",
+      argTypes: [{ name: "clipbordEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onCut: {
+      type: "eventHandler",
+      argTypes: [{ name: "clipbordEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onPaste: {
+      type: "eventHandler",
+      argTypes: [{ name: "clipbordEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onCompositionStart: {
+      type: "eventHandler",
+      argTypes: [{ name: "compositionEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onCompositionEnd: {
+      type: "eventHandler",
+      argTypes: [{ name: "compositionEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onCompositionUpdate: {
+      type: "eventHandler",
+      argTypes: [{ name: "compositionEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onSelect: {
+      type: "eventHandler",
+      argTypes: [{ name: "selectionEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onBeforeInput: {
+      type: "eventHandler",
+      argTypes: [{ name: "inputEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    onInput: {
+      type: "eventHandler",
+      argTypes: [{ name: "inputEvent", type: "object" }],
+      advanced: true,
+      hidden: hasParent
+    },
+    placeholder: {
+      type: "string"
+    }
+  };
+  const filteredProps = {};
+  propNames.forEach((propName) => {
+    if (Object.prototype.hasOwnProperty.call(commonProps, propName)) {
+      filteredProps[propName] = commonProps[propName];
+    }
+  });
+  return filteredProps;
+}
+
+export { getCommonProps as g, hasParent as h, resolveAutoComplete as r };
+//# sourceMappingURL=common-96be13c3.esm.js.map