@tribepad/themis 1.0.0

package/dist/elements/Accordion/Accordion.d.ts

@@ -0,0 +1,139 @@
+import type { AccordionProps, AccordionItemProps, AccordionTriggerProps, AccordionContentProps } from './Accordion.types';
+/**
+ * Accordion root CVA variants
+ *
+ * @see accordion-prd.md FR-001 (Accordion Root)
+ */
+export declare const accordionVariants: (props?: ({} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * AccordionItem CVA variants
+ *
+ * @see accordion-prd.md FR-002 (AccordionItem)
+ * @see accordion-prd.md DS-001 (Visual Design - borders)
+ */
+export declare const accordionItemVariants: (props?: ({} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * AccordionTrigger CVA variants
+ *
+ * @see accordion-prd.md FR-003 (AccordionTrigger)
+ * @see accordion-prd.md AR-006 (Touch Target Size - 44x44px)
+ * @see accordion-prd.md DS-002 (Typography)
+ */
+export declare const accordionTriggerVariants: (props?: ({} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Chevron icon CVA variants
+ *
+ * @see accordion-prd.md FR-010 (Animated Transitions)
+ */
+export declare const accordionChevronVariants: (props?: ({
+    isExpanded?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * AccordionContent CVA variants
+ *
+ * @see accordion-prd.md FR-004 (AccordionContent)
+ * @see accordion-prd.md FR-010 (Animated Transitions)
+ */
+export declare const accordionContentVariants: (props?: ({} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * AccordionContent inner wrapper CVA variants
+ */
+export declare const accordionContentInnerVariants: (props?: ({} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Accordion Root Component
+ *
+ * Container for accordion items. Manages expansion state and provides
+ * context to child components.
+ *
+ * @see accordion-prd.md FR-001 (Accordion Root Component)
+ * @see accordion-prd.md FR-005 (Single Expansion Mode)
+ * @see accordion-prd.md FR-006 (Multiple Expansion Mode)
+ * @see accordion-prd.md FR-007 (Controlled Mode)
+ * @see accordion-prd.md FR-008 (Uncontrolled Mode)
+ *
+ * @example
+ * // Uncontrolled single mode
+ * <Accordion type="single" collapsible>
+ *   <AccordionItem id="item-1">
+ *     <AccordionTrigger>Section 1</AccordionTrigger>
+ *     <AccordionContent>Content 1</AccordionContent>
+ *   </AccordionItem>
+ * </Accordion>
+ *
+ * @example
+ * // Controlled multiple mode
+ * <Accordion
+ *   type="multiple"
+ *   expandedKeys={expandedKeys}
+ *   onExpandedChange={setExpandedKeys}
+ * >
+ *   ...
+ * </Accordion>
+ */
+declare function AccordionRoot({ type, collapsible, expandedKeys, defaultExpandedKeys, onExpandedChange, isDisabled, disabledKeys, className, children, ...props }: AccordionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AccordionRoot {
+    var displayName: string;
+}
+/**
+ * AccordionItem Component
+ *
+ * Wrapper for each expandable disclosure section.
+ *
+ * @see accordion-prd.md FR-002 (AccordionItem Component)
+ *
+ * @example
+ * <AccordionItem id="faq-1" isDisabled={!isAuthenticated}>
+ *   <AccordionTrigger>Members-only FAQ</AccordionTrigger>
+ *   <AccordionContent>This content is for members only.</AccordionContent>
+ * </AccordionItem>
+ */
+declare function AccordionItemComponent({ id, isDisabled: isDisabledProp, className, children, ...props }: AccordionItemProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AccordionItemComponent {
+    var displayName: string;
+}
+/**
+ * AccordionTrigger Component
+ *
+ * Clickable button that toggles accordion content visibility.
+ * Wrapped in a Heading for proper document structure.
+ *
+ * @see accordion-prd.md FR-003 (AccordionTrigger Component)
+ * @see accordion-prd.md AR-002 (ARIA Attributes)
+ * @see accordion-prd.md AR-003 (Keyboard Navigation)
+ *
+ * @example
+ * // Default with chevron
+ * <AccordionTrigger>Is it accessible?</AccordionTrigger>
+ *
+ * @example
+ * // Custom heading level
+ * <AccordionTrigger as="h2">Important Section</AccordionTrigger>
+ *
+ * @example
+ * // Custom icon
+ * <AccordionTrigger icon={<PlusIcon className="h-4 w-4" />}>
+ *   Click to expand
+ * </AccordionTrigger>
+ */
+declare function AccordionTriggerComponent({ as: headingLevel, icon, hideIcon, className, children, ...props }: AccordionTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AccordionTriggerComponent {
+    var displayName: string;
+}
+declare function AccordionContentComponent({ preserveState, className, children, ...props }: AccordionContentProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AccordionContentComponent {
+    var displayName: string;
+}
+/**
+ * Direct named exports (not Object.assign compound pattern)
+ *
+ * Accordion follows React Aria's direct export pattern because:
+ * - Simpler structure (only 4 components)
+ * - Better tree-shaking with named exports
+ * - Clearer imports: import { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from '...'
+ */
+export declare const Accordion: typeof AccordionRoot;
+export declare const AccordionItem: typeof AccordionItemComponent;
+export declare const AccordionTrigger: typeof AccordionTriggerComponent;
+export declare const AccordionContent: typeof AccordionContentComponent;
+export type { AccordionProps, AccordionItemProps, AccordionTriggerProps, AccordionContentProps, };
+//# sourceMappingURL=Accordion.d.ts.map

package/dist/elements/Accordion/Accordion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Accordion.d.ts","sourceRoot":"","sources":["../../../src/elements/Accordion/Accordion.tsx"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EAEtB,MAAM,mBAAmB,CAAC;AAoB3B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,2FAG5B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,2FAUjC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,2FAuBpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;8EAoBpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,2FASpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,6BAA6B,2FAGxC,CAAC;AA0CH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iBAAS,aAAa,CAAC,EACrB,IAAe,EACf,WAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,EAChB,UAAkB,EAClB,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,cAAc,2CAmChB;kBA9CQ,aAAa;;;AAkDtB;;;;;;;;;;;;GAYG;AACH,iBAAS,sBAAsB,CAAC,EAC9B,EAAE,EACF,UAAU,EAAE,cAAc,EAC1B,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,kBAAkB,2CAkBpB;kBAxBQ,sBAAsB;;;AA4B/B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,yBAAyB,CAAC,EACjC,EAAE,EAAE,YAAmB,EACvB,IAAI,EACJ,QAAgB,EAChB,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,qBAAqB,2CA0BvB;kBAjCQ,yBAAyB;;;AAqFlC,iBAAS,yBAAyB,CAAC,EACjC,aAAqB,EACrB,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,qBAAqB,2CAavB;kBAlBQ,yBAAyB;;;AA0BlC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,sBAAgB,CAAC;AACvC,eAAO,MAAM,aAAa,+BAAyB,CAAC;AACpD,eAAO,MAAM,gBAAgB,kCAA4B,CAAC;AAC1D,eAAO,MAAM,gBAAgB,kCAA4B,CAAC;AAG1D,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,GACtB,CAAC"}

package/dist/elements/Accordion/Accordion.types.d.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import type { ReactNode, Key } from 'react';
+/**
+ * Accordion Type Schema
+ * Defines expansion mode: single (one item at a time) or multiple (any number)
+ *
+ * @see accordion-prd.md FR-005, FR-006 (Expansion Modes)
+ */
+export declare const AccordionTypeSchema: z.ZodEnum<{
+    single: "single";
+    multiple: "multiple";
+}>;
+export type AccordionType = z.infer<typeof AccordionTypeSchema>;
+/**
+ * Heading Level Schema
+ * Configurable heading level for document structure (h1-h6)
+ *
+ * @see accordion-prd.md FR-003 (AccordionTrigger with as prop)
+ */
+export declare const HeadingLevelSchema: z.ZodEnum<{
+    h1: "h1";
+    h2: "h2";
+    h3: "h3";
+    h4: "h4";
+    h5: "h5";
+    h6: "h6";
+}>;
+export type HeadingLevel = z.infer<typeof HeadingLevelSchema>;
+/**
+ * Key Schema for item identification
+ * Supports both string and number keys per React Aria convention
+ */
+export declare const KeySchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+/**
+ * Accordion root component props schema
+ *
+ * @see accordion-prd.md FR-001 (Accordion Root Component)
+ * @see accordion-prd.md FR-007 (Controlled Mode)
+ * @see accordion-prd.md FR-008 (Uncontrolled Mode)
+ */
+export declare const AccordionPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        single: "single";
+        multiple: "multiple";
+    }>>>;
+    collapsible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    expandedKeys: z.ZodOptional<z.ZodCustom<Set<Key>, Set<Key>>>;
+    defaultExpandedKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    onExpandedChange: z.ZodOptional<z.ZodCustom<(keys: Set<Key>) => void, (keys: Set<Key>) => void>>;
+    isDisabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    disabledKeys: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    children: z.ZodCustom<ReactNode, ReactNode>;
+}, z.core.$strip>;
+export type AccordionProps = z.infer<typeof AccordionPropsSchema>;
+/**
+ * AccordionItem component props schema
+ *
+ * @see accordion-prd.md FR-002 (AccordionItem Component)
+ */
+export declare const AccordionItemPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    isDisabled: z.ZodOptional<z.ZodBoolean>;
+    children: z.ZodCustom<ReactNode, ReactNode>;
+}, z.core.$strip>;
+export type AccordionItemProps = z.infer<typeof AccordionItemPropsSchema>;
+/**
+ * AccordionTrigger component props schema
+ *
+ * @see accordion-prd.md FR-003 (AccordionTrigger Component)
+ */
+export declare const AccordionTriggerPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    as: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        h1: "h1";
+        h2: "h2";
+        h3: "h3";
+        h4: "h4";
+        h5: "h5";
+        h6: "h6";
+    }>>>;
+    icon: z.ZodOptional<z.ZodCustom<ReactNode, ReactNode>>;
+    hideIcon: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    children: z.ZodCustom<ReactNode, ReactNode>;
+}, z.core.$strip>;
+export type AccordionTriggerProps = z.infer<typeof AccordionTriggerPropsSchema>;
+/**
+ * AccordionContent component props schema
+ *
+ * @see accordion-prd.md FR-004 (AccordionContent Component)
+ * @see accordion-prd.md FR-010 (Animated Transitions)
+ */
+export declare const AccordionContentPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    preserveState: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    children: z.ZodCustom<ReactNode, ReactNode>;
+}, z.core.$strip>;
+export type AccordionContentProps = z.infer<typeof AccordionContentPropsSchema>;
+//# sourceMappingURL=Accordion.types.d.ts.map

package/dist/elements/Accordion/Accordion.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Accordion.types.d.ts","sourceRoot":"","sources":["../../../src/elements/Accordion/Accordion.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAAiC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;EAA+C,CAAC;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,SAAS,iDAAoC,CAAC;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;uDAeG,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,SAAjB,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI;;;;iBAUnD,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;iBASnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;iBAYtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;iBAQtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/elements/Accordion/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Accordion Component - Barrel Exports
+ *
+ * @see Accordion.tsx (Component implementation)
+ * @see Accordion.types.ts (Zod schemas and types)
+ * @see accordion-prd.md (Requirements)
+ */
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent, } from './Accordion';
+export { accordionVariants, accordionItemVariants, accordionTriggerVariants, accordionChevronVariants, accordionContentVariants, accordionContentInnerVariants, } from './Accordion';
+export type { AccordionProps, AccordionItemProps, AccordionTriggerProps, AccordionContentProps, } from './Accordion';
+export { AccordionTypeSchema, HeadingLevelSchema, KeySchema, AccordionPropsSchema, AccordionItemPropsSchema, AccordionTriggerPropsSchema, AccordionContentPropsSchema, } from './Accordion.types';
+export type { AccordionType, HeadingLevel, } from './Accordion.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/Accordion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/Accordion/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,EACxB,6BAA6B,GAC9B,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,aAAa,EACb,YAAY,GACb,MAAM,mBAAmB,CAAC"}

package/dist/elements/Accordion/index.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var chunkCKNISJOQ_js = require('../../chunk-CKNISJOQ.js');
+require('../../chunk-VIREG536.js');
+require('../../chunk-T4COXKQ3.js');
+
+
+
+Object.defineProperty(exports, "Accordion", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.Accordion; }
+});
+Object.defineProperty(exports, "AccordionContent", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionContent; }
+});
+Object.defineProperty(exports, "AccordionContentPropsSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionContentPropsSchema; }
+});
+Object.defineProperty(exports, "AccordionItem", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionItem; }
+});
+Object.defineProperty(exports, "AccordionItemPropsSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionItemPropsSchema; }
+});
+Object.defineProperty(exports, "AccordionPropsSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionPropsSchema; }
+});
+Object.defineProperty(exports, "AccordionTrigger", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionTrigger; }
+});
+Object.defineProperty(exports, "AccordionTriggerPropsSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionTriggerPropsSchema; }
+});
+Object.defineProperty(exports, "AccordionTypeSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.AccordionTypeSchema; }
+});
+Object.defineProperty(exports, "HeadingLevelSchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.HeadingLevelSchema; }
+});
+Object.defineProperty(exports, "KeySchema", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.KeySchema; }
+});
+Object.defineProperty(exports, "accordionChevronVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionChevronVariants; }
+});
+Object.defineProperty(exports, "accordionContentInnerVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionContentInnerVariants; }
+});
+Object.defineProperty(exports, "accordionContentVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionContentVariants; }
+});
+Object.defineProperty(exports, "accordionItemVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionItemVariants; }
+});
+Object.defineProperty(exports, "accordionTriggerVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionTriggerVariants; }
+});
+Object.defineProperty(exports, "accordionVariants", {
+  enumerable: true,
+  get: function () { return chunkCKNISJOQ_js.accordionVariants; }
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/elements/Accordion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/elements/Accordion/index.mjs

@@ -0,0 +1,5 @@
+export { Accordion, AccordionContent, AccordionContentPropsSchema, AccordionItem, AccordionItemPropsSchema, AccordionPropsSchema, AccordionTrigger, AccordionTriggerPropsSchema, AccordionTypeSchema, HeadingLevelSchema, KeySchema, accordionChevronVariants, accordionContentInnerVariants, accordionContentVariants, accordionItemVariants, accordionTriggerVariants, accordionVariants } from '../../chunk-NYQYHT76.mjs';
+import '../../chunk-E2KQFV3O.mjs';
+import '../../chunk-5SVLJN2C.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/elements/Accordion/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/elements/Avatar/Avatar.d.ts

@@ -0,0 +1,51 @@
+import type { AvatarProps, AvatarSize, AvatarShape, AvatarStatus } from './Avatar.types';
+/**
+ * Layer 1: Transparent outer touch target (44x44px minimum)
+ * Handles WCAG 2.2 AAA touch target requirement
+ * IMPORTANT: Focus ring stays on Layer 1 for AAA compliance (2.4.13)
+ */
+export declare const avatarOuterVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+    interactive?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Layer 2: Visual avatar appearance
+ * Provides the visual appearance with configurable size, shape, and status ring
+ */
+export declare const avatarVisualVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+    shape?: "circle" | "rounded" | null | undefined;
+    status?: "online" | "offline" | "busy" | "away" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * Avatar Component - 3-Layer Architecture
+ * Displays user avatar with image or initials fallback
+ *
+ * Layer 1: Touch Target - 44x44px WCAG AAA compliant
+ * Layer 2: Visual Avatar - configurable appearance
+ * Layer 3: Content - image, initials, or loading skeleton
+ */
+declare const Avatar: import("react").NamedExoticComponent<Omit<{
+    alt: string;
+    size: "default" | "sm" | "lg";
+    shape: "circle" | "rounded";
+    className?: string | undefined;
+    children?: any;
+    id?: string | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-live'?: "off" | "polite" | "assertive" | undefined;
+    'aria-hidden'?: boolean | undefined;
+    'data-testid'?: string | undefined;
+    src?: string | undefined;
+    name?: string | undefined;
+    status?: "online" | "offline" | "busy" | "away" | undefined;
+    onPress?: import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | undefined;
+}, "onPress"> & {
+    onPress?: (e: import("react-aria").PressEvent) => void;
+    _groupIndex?: number;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export { Avatar };
+export type { AvatarProps, AvatarSize, AvatarShape, AvatarStatus };
+//# sourceMappingURL=Avatar.d.ts.map

package/dist/elements/Avatar/Avatar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../src/elements/Avatar/Avatar.tsx"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EAEb,MAAM,gBAAgB,CAAC;AA0BxB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;8EA8B/B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;8EAgChC,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;kDAkIX,CAAC;AAIF,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC"}

package/dist/elements/Avatar/Avatar.types.d.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import type { PressEvent } from 'react-aria-components';
+/**
+ * Avatar size schema
+ *
+ * Size mappings (visual | touch target | overlap):
+ * - sm: 32px | 44x44px | 8px
+ * - default: 44px | 44x44px | 12px
+ * - lg: 48px | 48x48px | 16px
+ *
+ * @see plan.md Clarification 6 (Overlap Scale)
+ * @see spec.md FR-009 (WCAG 2.2 AAA - 44x44px touch targets)
+ */
+export declare const AvatarSizeSchema: z.ZodEnum<{
+    default: "default";
+    sm: "sm";
+    lg: "lg";
+}>;
+export type AvatarSize = z.infer<typeof AvatarSizeSchema>;
+/**
+ * Avatar shape schema
+ * - circle: Fully rounded (rounded-full)
+ * - rounded: Rounded corners (rounded-lg)
+ */
+export declare const AvatarShapeSchema: z.ZodEnum<{
+    circle: "circle";
+    rounded: "rounded";
+}>;
+export type AvatarShape = z.infer<typeof AvatarShapeSchema>;
+/**
+ * Avatar status schema for ring indicators
+ *
+ * Status ring colors:
+ * - online: green (#22c55e)
+ * - offline: gray (#6b7280)
+ * - busy: red (#ef4444)
+ * - away: yellow (#eab308)
+ */
+export declare const AvatarStatusSchema: z.ZodEnum<{
+    online: "online";
+    offline: "offline";
+    busy: "busy";
+    away: "away";
+}>;
+export type AvatarStatus = z.infer<typeof AvatarStatusSchema>;
+/**
+ * Overlap values by size (in pixels)
+ * @see plan.md Clarification 6 (Overlap Scale)
+ */
+export declare const AVATAR_OVERLAP_BY_SIZE: Record<AvatarSize, number>;
+/**
+ * Avatar props schema extending BaseComponentProps
+ *
+ * @see React Aria Button: https://react-aria.adobe.com/Button
+ * @see ShadCN Avatar: https://ui.shadcn.com/docs/components/avatar
+ * @see plan.md Phase 1 (Type System)
+ * @see constitution.md Principle IV (Accessibility First)
+ */
+export declare const AvatarPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    children: z.ZodOptional<z.ZodAny>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    src: z.ZodOptional<z.ZodString>;
+    alt: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        sm: "sm";
+        lg: "lg";
+    }>>>;
+    shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        circle: "circle";
+        rounded: "rounded";
+    }>>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        online: "online";
+        offline: "offline";
+        busy: "busy";
+        away: "away";
+    }>>;
+    onPress: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+}, z.core.$strip>;
+export type AvatarProps = Omit<z.infer<typeof AvatarPropsSchema>, 'onPress'> & {
+    /** Click handler for actionable avatar */
+    onPress?: (e: PressEvent) => void;
+    /**
+     * Internal: Position index within AvatarGroup (0-indexed)
+     * Used to progressively darken backgrounds in groups
+     * @internal Set by AvatarGroup, do not use directly
+     */
+    _groupIndex?: number;
+};
+/**
+ * Avatar group props schema extending BaseComponentProps
+ *
+ * @see plan.md Clarification 1 (Group Border)
+ * @see plan.md Clarification 5 (Stack Order - first on top)
+ * @see plan.md Clarification 7 (Border Scope - groups only)
+ */
+export declare const AvatarGroupPropsSchema: z.ZodObject<{
+    className: z.ZodOptional<z.ZodString>;
+    children: z.ZodOptional<z.ZodAny>;
+    id: z.ZodOptional<z.ZodString>;
+    'aria-label': z.ZodOptional<z.ZodString>;
+    'aria-labelledby': z.ZodOptional<z.ZodString>;
+    'aria-describedby': z.ZodOptional<z.ZodString>;
+    'aria-live': z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        polite: "polite";
+        assertive: "assertive";
+    }>>;
+    'aria-hidden': z.ZodOptional<z.ZodBoolean>;
+    'data-testid': z.ZodOptional<z.ZodString>;
+    max: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        circle: "circle";
+        rounded: "rounded";
+    }>>>;
+    size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        sm: "sm";
+        lg: "lg";
+    }>>>;
+    onPress: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+}, z.core.$strip>;
+export type AvatarGroupProps = Omit<z.infer<typeof AvatarGroupPropsSchema>, 'onPress'> & {
+    /** Click handler for the entire group */
+    onPress?: (e: PressEvent) => void;
+};
+/**
+ * Internal loading state for avatar images
+ * @see plan.md Clarification 4 (Loading State)
+ */
+export type AvatarLoadingState = 'loading' | 'loaded' | 'error';
+//# sourceMappingURL=Avatar.types.d.ts.map

package/dist/elements/Avatar/Avatar.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.types.d.ts","sourceRoot":"","sources":["../../../src/elements/Avatar/Avatar.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGxD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB;;;;EAAkC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;EAAgC,CAAC;AAC/D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;EAAgD,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAI7D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiC5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,EAAE,SAAS,CAAC,GAAG;IAC7E,0CAA0C;IAC1C,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,EAAE,SAAS,CAAC,GAAG;IACvF,yCAAyC;IACzC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;CACnC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC"}

package/dist/elements/Avatar/AvatarGroup.d.ts

@@ -0,0 +1,32 @@
+import type { AvatarGroupProps } from './Avatar.types';
+/**
+ * Overflow indicator variants (the +X badge)
+ */
+declare const avatarOverflowVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+    shape?: "circle" | "rounded" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * AvatarGroup Component
+ * Groups multiple Avatar components with overlap and overflow handling
+ */
+declare const AvatarGroup: import("react").NamedExoticComponent<Omit<{
+    max: number;
+    shape: "circle" | "rounded";
+    size: "default" | "sm" | "lg";
+    className?: string | undefined;
+    children?: any;
+    id?: string | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-live'?: "off" | "polite" | "assertive" | undefined;
+    'aria-hidden'?: boolean | undefined;
+    'data-testid'?: string | undefined;
+    onPress?: import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | undefined;
+}, "onPress"> & {
+    onPress?: (e: import("react-aria").PressEvent) => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export { AvatarGroup, avatarOverflowVariants };
+export type { AvatarGroupProps };
+//# sourceMappingURL=AvatarGroup.d.ts.map

package/dist/elements/Avatar/AvatarGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarGroup.d.ts","sourceRoot":"","sources":["../../../src/elements/Avatar/AvatarGroup.tsx"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,gBAAgB,EAA2B,MAAM,gBAAgB,CAAC;AAYhF;;GAEG;AACH,QAAA,MAAM,sBAAsB;;;8EA0B3B,CAAC;AAwBF;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;kDAyKhB,CAAC;AAIF,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,CAAC;AAC/C,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/elements/Avatar/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Avatar Component Barrel Exports
+ *
+ * @see avatar-prd.md for component requirements
+ * @see plan.md for implementation details
+ */
+export { Avatar, avatarOuterVariants, avatarVisualVariants } from './Avatar';
+export { AvatarGroup, avatarOverflowVariants } from './AvatarGroup';
+export type { AvatarProps, AvatarGroupProps, AvatarSize, AvatarShape, AvatarStatus, AvatarLoadingState, } from './Avatar.types';
+export { AvatarPropsSchema, AvatarGroupPropsSchema, AvatarSizeSchema, AvatarShapeSchema, AvatarStatusSchema, AVATAR_OVERLAP_BY_SIZE, } from './Avatar.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/Avatar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/Avatar/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAGpE,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,YAAY,EACZ,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC"}