CHECKLIST.md

VueForge Core Baseline Checklist (Component-by-Component)

Goal: build a competitive core UI library where teams can ship most interfaces with VueForge alone and minimal custom CSS.

Priority rules:

• P0 = core baseline required for competitiveness
• P1 = advanced competitiveness features
• P2 = scaling, ecosystem, and adoption

Execution rules:

• Work in strict order: P0 -> P1 -> P2.
• Inside each priority, work top-to-bottom.
• Mark an item done only when code + tests + docs are complete.

Definition of Done (applies to each item):

• Implementation is complete and exported (if public component/API).
• Tests are added/updated and passing.
• Accessibility checks are covered for interactive behavior.
• Documentation is updated (API + usage example).
• Changelog/release note entry is prepared (for user-facing changes).
• Responsive behavior is verified for mobile/tablet/desktop breakpoints (including touch and overflow handling).
• SSR/hydration behavior is verified for interactive/dynamic rendering paths.
• Visual regression coverage is added/updated for critical variants and states.

P0 first slice (ship this first):

1. P0.1 Container
2. P0.2 Section
3. P0.3 Grid
4. P0.4 Stack
5. P0.5 Inline
6. P0.10 DataTable production baseline
7. P0.11 Form DX baseline
8. P0.22 Core accessibility QA gate
9. P0.23 Core documentation baseline
10. P0.24 API consistency baseline
11. P0.25 Browser support baseline

Execution dependencies:

1. Layout docs and recipes depend on P0.1-P0.5.
2. A11y docs and audits in P0.22 depend on component hardening tasks.
3. P0.23 docs template should be finalized before mass docs updates.
4. P0.24 API conventions should be defined before API normalization changes.
5. P1 work starts only after P0 first slice is mostly completed.

P0 (Mandatory Core Baseline)

P0.0 AppShell (existing)

• AppShell component is implemented
• Audit shell accessibility and landmark semantics
• Add docs recipe for app-level layout composition

P0.1 Container (new)

• Define props: size, maxWidth, paddingX, as
• Implement responsive paddings and max-width behavior
• Add theme tokens and typings
• Add unit tests (props, classes, slots)
• Export from src/index.ts
• Add docs (API + examples)

P0.2 Section (new)

• Define props: paddingY, background, bordered, as
• Implement vertical rhythm and background variants
• Add theme tokens and typings
• Add unit tests
• Export from src/index.ts
• Add docs (composition with Container)

P0.3 Grid (new)

• Define props: columns, gaps, breakpoints, align, justify
• Add item API for span/start/end
• Implement responsive class/style generation
• Add theme tokens and typings
• Add unit tests (breakpoints and span behavior)
• Export from src/index.ts
• Add docs (layout recipes)

P0.4 Stack (new)

• Define props: gap, align, justify, wrap, as
• Implement vertical layout primitive
• Add theme tokens and typings
• Add unit tests
• Export from src/index.ts
• Add docs

P0.5 Inline (new)

• Define props: gap, align, justify, wrap, as
• Implement horizontal layout primitive
• Add theme tokens and typings
• Add unit tests
• Export from src/index.ts
• Add docs

P0.6 Menu (existing hardening)

• Menu component is implemented
• Audit keyboard navigation for nested items
• Ensure ARIA roles/states are complete
• Add official presets/examples: top-nav and sidebar-nav
• Add tests for keyboard and active-state behavior
• Add a11y section in docs

P0.7 Link (existing hardening)

• Link component is implemented
• Verify disabled/accessibility semantics for router and anchor modes
• Add focus-visible consistency
• Add tests for keyboard and aria-disabled behavior
• Add docs notes for external/internal links

P0.8 PageHeader (existing hardening)

• PageHeader component is implemented
• Audit heading semantics (h1 usage rules in docs)
• Verify slot accessibility for actions/meta
• Add tests for responsive behavior
• Add docs examples with Breadcrumbs and actions

P0.9 Breadcrumbs (existing hardening)

• Breadcrumbs component is implemented
• Verify aria-label defaults and nav semantics
• Add tests for active item and separator behavior
• Add docs for accessibility usage

P0.10 DataTable (core production baseline)

• DataTable component is implemented
• Define server-mode API contracts (props + emitted events)
• Implement server-mode handoff for sorting
• Implement server-mode handoff for pagination
• Implement server-mode handoff for filtering
• Define row selection API shape
• Implement row selection (single)
• Implement row selection (multi)
• Add bulk action integration points/events
• Implement sticky header behavior
• Implement sticky columns behavior
• Add tests: server-mode sorting/pagination/filtering
• Add tests: selection and bulk action hooks
• Add tests: sticky header/columns
• Add tests: keyboard focus behavior in interactive table state
• Add docs recipe: server-side table
• Add docs recipe: selectable table with bulk actions
• Add docs recipe: sticky header/columns

P0.11 Form (core DX baseline)

• Form component is implemented
• Define official async submit pattern in API/docs
• Add zod adapter example
• Add yup adapter example
• Add tests for async validation and submit error handling
• Add docs recipes: async submit, API errors, reset flows

P0.12 FormField (existing hardening)

• FormField component is implemented
• Validate aria-describedby wiring in all states
• Ensure error/hint/required semantics are consistent
• Add tests for slot props and accessibility
• Add docs do/don't examples

P0.13 Input family (existing hardening)

• Input family baseline is implemented (Input, Textarea, NumberInput, PasswordInput, MaskedInput, OtpInput)
• Input family audit framework is defined (shared keyboard + ARIA checklist)
• Input keyboard/focus-visible/ARIA audit + tests
• Textarea keyboard/focus-visible/ARIA audit + tests
• NumberInput keyboard/focus-visible/ARIA audit + tests
• PasswordInput keyboard/focus-visible/ARIA audit + tests
• MaskedInput keyboard/focus-visible/ARIA audit + tests
• OtpInput keyboard/focus-visible/ARIA audit + tests
• Add consolidated docs matrix for shared input props (size, variant, disabled, readonly)

P0.14 Selection family (existing hardening)

• Selection family baseline is implemented (Select, Autocomplete, Combobox, MultiSelect, TagInput, TreeSelect)
• Selection family audit framework is defined (open/close, focus, keyboard, ARIA)
• Select audit + tests (keyboard, clearability, disabled states)
• Autocomplete audit + tests (search, navigation, selection)
• Combobox audit + tests (custom value flows, keyboard)
• MultiSelect audit + tests (multi selection, chip removal, clearability)
• TagInput audit + tests (token creation/removal, keyboard)
• TreeSelect audit + tests (hierarchy navigation, selection behavior)
• Standardize active/selected/disabled behavior across the family
• Add docs patterns for simple, large-list, and async options

P0.15 Date/time family (existing hardening)

• Date/time family baseline is implemented (DatePicker, Calendar, DateRangePicker, TimePicker, DateTimePicker)
• Date/time family audit framework is defined (keyboard + parsing + constraints)
• DatePicker audit + tests
• Calendar audit + tests
• DateRangePicker audit + tests
• TimePicker audit + tests
• DateTimePicker audit + tests
• Add docs for constraints and parsing/format behavior
• Add edge-case tests (empty/null/range boundaries)

P0.16 Modal (overlay baseline)

• Modal component is implemented
• Verify focus trap and focus restore contracts
• Verify escape and outside-click behavior contracts
• Verify scroll-lock behavior
• Align z-index policy
• Add regression tests
• Add docs interaction contract

P0.17 Drawer (overlay baseline)

• Drawer component is implemented
• Verify focus trap and focus restore contracts
• Verify escape and outside-click behavior contracts
• Verify scroll-lock behavior
• Align z-index policy
• Add regression tests
• Add docs interaction contract

P0.18 Dropdown (overlay baseline)

• Dropdown component is implemented
• Verify keyboard open/close/navigation/select behavior
• Verify positioning and viewport collision behavior
• Align z-index policy
• Add regression tests
• Add docs interaction contract

P0.19 Popover (overlay baseline)

• Popover component is implemented
• Verify trigger/focus behavior and dismiss rules
• Verify positioning and collision behavior
• Align z-index policy
• Add regression tests
• Add docs interaction contract

P0.20 Tooltip (overlay baseline)

• Tooltip component is implemented
• Verify keyboard/focus access and delays
• Verify non-hover accessibility behavior
• Align z-index policy
• Add regression tests
• Add docs usage constraints

P0.21 ContextMenu (overlay baseline)

• ContextMenu component is implemented
• Verify keyboard fallback and close behavior
• Verify positioning and collision behavior
• Align z-index policy
• Add regression tests
• Add docs interaction contract

P0.22 Core accessibility QA gate

• Define shared a11y checklist template for interactive components
• Define a11y checklist template for non-interactive/display components
• Add accessibility test suite: form flows
• Add accessibility test suite: table flows
• Add accessibility test suite: modal/drawer flows
• Add accessibility test suite: navigation flows
• Enforce required a11y docs section in component docs template

P0.23 Core documentation baseline

• Define standard docs template sections: Props, Events, Slots, A11y, Theming, Recipes
• Apply docs template to layout primitives (Container, Section, Grid, Stack, Inline)
• Apply docs template to navigation components (Menu, Link, PageHeader, Breadcrumbs)
• Apply docs template to overlays (Modal, Drawer, Dropdown, Popover, Tooltip, ContextMenu)
• Apply docs template to data components (DataTable, Pagination, VirtualScroller, Card, Divider)
• Apply docs template to forms and input families (Form, FormField, input/selection/date-time groups)
• Add "Build without Tailwind" guide
• Add starter recipe: auth page
• Add starter recipe: dashboard page
• Add starter recipe: settings page

P0.24 API consistency baseline (cross-library)

• Define API conventions: prop naming and defaults
• Define API conventions: emitted event naming
• Define API conventions: slot naming and slot-prop patterns
• Define API conventions: v-model contracts and controlled/uncontrolled behavior
• Audit layout components against conventions
• Audit navigation components against conventions
• Audit data components against conventions
• Audit overlays against conventions
• Audit form/input/select/date-time families against conventions
• Normalize high-priority inconsistencies (breaking-safe changes first)
• Add migration notes for any normalized behavior
• Add tests/docs notes for normalized contracts

P0.25 Browser support baseline

• Define official browser support matrix
• Add compatibility checks for critical components against matrix
• Document supported browsers and known limitations

P0.26 Core theme system (existing hardening)

• Theme runtime API is implemented (setTheme, updateTheme, getTheme)
• Component token override system is implemented
• Add stricter token validation guidance in docs
• Add token usage examples for layout primitives

P0.27 Core test baseline (existing hardening)

• Unit-test baseline exists for many components
• Define minimum test coverage expectations for new/updated components
• Enforce test checklist in contribution/review process

P0.28 Implemented coverage reconciliation

Goal: ensure every currently exported public component is explicitly tracked in checklist scope with quality expectations.

Hardening gate (mandatory for each implemented component):

• API contract is documented and consistent (props/events/slots/defaults + migration note if behavior changes).
• Tests are complete for render, interaction, edge cases, and regression-sensitive paths.
• Accessibility contracts are verified (keyboard, ARIA, focus management where applicable).
• Responsive behavior is verified on mobile/tablet/desktop breakpoints, including touch and overflow handling.
• SSR/hydration behavior is verified for interactive/dynamic rendering paths.
• Visual regression coverage exists for critical variants/states.
• Docs include API reference and at least one production-style recipe.
• Component row in docs/audits/component-compliance-matrix.md is updated.

Completion gate for P0.28:

• docs/audits/component-compliance-matrix.md has no No values for implemented components (only Yes or justified N/A).
• Every currently exported public component from src/index.ts is present in checklist scope and compliance matrix.

Policy for all future components:

• No new public component can be marked complete unless all quality gates are Yes (or justified N/A) in the compliance matrix.

Backfill execution waves for implemented components:

• Wave 1: backfill compliance gates for P0 first-slice components and shared layout primitives.
• Wave 2: backfill compliance gates for input/selection/date-time families and overlays.
• Wave 3: backfill compliance gates for advanced/data-heavy and DX components (DataTable, Tree, VirtualScroller, TreeTable, DataView).
• Wave 4: close remaining implemented components and reach fully green compliance matrix.
• Create full rollout plan for all implemented and planned components: docs/audits/component-rollout-plan.md.
• Create API package specification document for all implemented/planned rollout packages: docs/audits/component-api-package-specs.md.
• Execute rollout packages and keep component-compliance / planned-component-compliance matrices synchronized.
• Enforce per-package API spec completion (props/events/slots/a11y/responsive/SSR/tokens/tests) before package closeout.

Wave 1 execution plan (PR packages):

• W1-PR1 Layout core: Container, Section, Grid, GridItem.
• W1-PR2 Layout flow: Stack, Inline, AppShell.
• W1-PR3 Navigation shell: Menu, Link, Breadcrumbs, PageHeader.
• W1-PR4 Surface baseline: Card, Divider, EmptyState, Skeleton.
• W1-PR5 Controls baseline: Button, ButtonGroup, SegmentedControl, Spinner, Progress.
• W1-PR6 Wave closeout: resolve open QA findings, sync compliance matrix rows, and mark Wave 1 done.

Wave 1 package gate (applies to each W1-PR*):

• All touched component rows are Yes/justified N/A across DoD, Tests, A11y, SSR/Hydration, Responsive, Visual, Docs, Catalog.

• npm run lint, npm run typecheck, targeted npm run test, and npm run test:ssr are green.

• At least one production-style docs recipe is updated/added for touched component group.

• AccordionItem hardening baseline (API, tests, a11y/docs confirmation)

• ColorPicker hardening baseline (API, tests, a11y/docs confirmation)

• ConfirmDialog hardening baseline (API, tests, a11y/docs confirmation)

• EmptyState hardening baseline (API, tests, a11y/docs confirmation)

• FilterChips hardening baseline (API, tests, a11y/docs confirmation)

• GridItem hardening baseline (API, tests, a11y/docs confirmation)

• InlineEdit hardening baseline (API, tests, a11y/docs confirmation)

• InputAddon hardening baseline (API, tests, a11y/docs confirmation)

• InputGroup hardening baseline (API, tests, a11y/docs confirmation)

• RadioButton hardening baseline (API, tests, a11y/docs confirmation)

• RadioGroup hardening baseline (API, tests, a11y/docs confirmation)

• SegmentedControl hardening baseline (API, tests, a11y/docs confirmation)

• Slider hardening baseline (API, tests, a11y/docs confirmation)

• Spinner hardening baseline (API, tests, a11y/docs confirmation)

• SplitButton hardening baseline (API, tests, a11y/docs confirmation)

• SplitterPanel hardening baseline (API, tests, a11y/docs confirmation)

• TabPanel hardening baseline (API, tests, a11y/docs confirmation)

• ToastContainer hardening baseline (API, tests, a11y/docs confirmation)

P1 (Advanced Competitiveness)

P1.1 DataTable advanced

• Add column resize
• Add column reorder
• Add tests for resize/reorder
• Add docs for advanced usage

P1.2 Tree and TreeSelect hardening

• Improve keyboard navigation edge cases
• Add tests for large tree behavior
• Add RTL behavior verification
• Add advanced docs recipes

P1.3 Tabs / Accordion / Stepper hardening

• Audit keyboard and ARIA behavior for all four components
• Add regression tests for navigation and state transitions
• Add docs recipes for common multi-step flows and disclosures
• Normalize shared API patterns where applicable

P1.4 Toast hardening

• Toast is implemented
• Define interaction and accessibility contracts
• Add keyboard and focus management regression tests
• Verify overlay/layering behavior against global policy
• Add docs recipes for real app usage patterns

P1.5 Date/time locale maturity

• Add global locale configuration for date/time components
• Add locale-aware week/day behavior
• Add tests for locale-specific behavior
• Add docs for locale setup

P1.6 Theme density and motion

• Add density presets (comfortable, compact)
• Add motion token guidance
• Add reduced-motion support
• Add tests/docs for density and motion behavior

P1.7 Visual and runtime quality pipeline

• Add visual regression testing pipeline
• Add SSR/hydration checks
• Add CI jobs for both
• Add regression triage playbook

P1.8 i18n and RTL baseline

• Add global locale text API (empty/loading/default labels)
• Localize built-in component strings
• Add RTL support for critical components
• Add regression tests for RTL
• Add i18n/RTL documentation

P1.9 Performance baseline for heavy components

• Define performance budgets for DataTable, Tree, VirtualScroller, and key overlays
• Add benchmark scenarios and measurement scripts
• Add CI/per-release performance checks
• Document performance guidance and limits

P1.10 Developer experience

• Add live playground for core components
• Add cookbook of copy-paste core recipes

P1.11 Component parity track

Goal: close high-demand component gaps before full focus on adoption/governance tasks in P2.

Exit criteria:

• Reach at least 80% completion of Must-have parity items.
• Each completed item must satisfy Definition of Done (code + tests + docs + a11y).

Must-have parity (build most business UIs without external UI kits)

• DialogService and ConfirmService APIs (programmatic open/close + promise flow)
• TreeTable component (hierarchical rows + expand/collapse + selection)
• DataView component (list/grid renderer with pagination/sorting handoff)
• Listbox component parity (single/multi select, keyboard-first navigation, grouped options)
• MenuBar component (horizontal app navigation with nested items)
• MegaMenu component (multi-column navigation content)
• PanelMenu component (accordion-style navigation tree)
• Carousel component (keyboard + swipe + autoplay controls)
• SpeedDial / floating action menu pattern
• Image component with preview/lightbox mode
• Skeleton advanced presets parity (table/list/form presets)
• OverlayPanel v1 alias parity (Popover-backed API subset with compatibility mapping)
• Pass-through/unstyled customization API (class/style slots and render hooks without forking components)

Must-have acceptance criteria (applies to each item):

• Keyboard and ARIA contracts documented and covered by regression tests.
• SSR/hydration behavior verified where interaction is dynamic.
• Responsive behavior verified across mobile/tablet/desktop breakpoints (including touch targets and overflow handling).
• Theming tokens are exposed and documented.
• At least one production-style docs recipe is added.

High-leverage parity (commonly requested after core launch)

• TreeTable advanced mode (lazy loading + server handoff + column resize/reorder)
• DataTable parity expansion (row group, row expansion, column visibility manager)
• Panel / Fieldset / Toolbar parity set (layout actions, toggle/collapse patterns, grouped controls)
• BlockUI / loading overlay component
• ScrollPanel and ScrollTop utilities
• PickList / OrderList parity (transfer, reorder, keyboard and drag/drop coverage)
• Splitter parity hardening (nested panels + persistence + keyboard edge cases)
• OrgChart component
• Virtualized Select/Autocomplete parity for large datasets (windowing + async loading UX)
• Image advanced mode (preview group, zoom steps, keyboard nav, download/alt guidance)
• Icon system parity (official icon package strategy, tree-shaking, size/color/theming contracts)
• MenuBar/MegaMenu/PanelMenu routing parity (router integration, active state sync, lazy child loading)
• Headless parity matrix for key components (documented slot/part API coverage and tested contracts)

Nice-to-have parity (post-adoption expansion)

• Dock / app launcher navigation pattern
• Galleria / gallery-focused media component
• Knob / radial input
• Inplace display-edit pattern parity checks

ICP-driven optional parity (enable based on target product segments)

• Autocomplete advanced parity (multi-value chips + grouped options + async grouping)
• Message / inline status-message component parity and guidance vs Alert
• Sidebar alias parity (Drawer-backed compatibility API + migration guidance)
• Headless/unstyled track hardening (unstyled docs recipes + slot/part coverage matrix)

P1.13 SaaS application component coverage

Goal: ensure the library can ship full-featured SaaS products (admin panels, ops backoffice, analytics, collaboration) without relying on additional UI kits.

SaaS core gaps (additions to parity track)

• BulkActionBar component (selection-aware actions with confirm/undo hooks)
• TieredMenu v1 alias parity (Menu preset/mode for hierarchical navigation)
• TabMenu component (route-aware section navigation for dashboard/detail pages)
• CascadeSelect component (hierarchical selection with async branch loading support)
• ConfirmPopup component (anchor-based confirm interactions for row/list actions)
• DynamicDialog service/component pair (programmatic modal composition for feature modules)
• CommentThread component (inline replies, mentions, resolve/reopen flows)
• MeterGroup component (progressive KPI blocks with thresholds and labels)
• OverlayBadge utility component/directive (status/count overlays for actionable icons)
• InlineMessage component (field-local status/error/info messaging separate from global alerts)
• JSONViewer component (expand/collapse, syntax highlight, path copy)
• DiffViewer component (inline/split modes for text/JSON payload comparison)
• InfiniteScroll utility/component (cursor/offset loading with sentinel and recovery states)

SaaS hardening for existing components

• DataTable SaaS ops mode (server-driven saved filters, export hooks, long-running action states)
• Tree hardening as TreeView parity (virtualized expansion, selection modes, async branch states)
• Accordion hardening as ExpansionPanel parity (dense mode, grouped control patterns, analytics hooks)
• Rating hardening for form/review scenarios (readonly precision, keyboard/a11y edge cases)

SaaS acceptance criteria (applies to each item):

• RBAC-friendly API boundaries are documented (what is UI-only vs permission-enforced by backend).
• Large-dataset behavior is validated (pagination/virtualization/loading and empty/error states).
• Internationalization and timezone-sensitive behavior are covered where relevant.
• At least one end-to-end SaaS recipe is added (list page, detail page, or settings/billing flow).

P1.14 Layout parity

Goal: provide production-grade application layout patterns for complex SaaS products across desktop and mobile without custom layout scaffolding.

Missing layout primitives and shells

• AppBar component (fixed/sticky/dense variants, action slots, responsive behavior)
• NavigationRail component (collapsed/expanded states, icon+label patterns, keyboard support)
• Footer component (app/page footer layout with left/center/right slots)
• PageLayout preset component (sidebar/content/aside composition with responsive collapse)
• SplitLayout presets (master-detail, inspector panel, and editor-preview compositions)
• ResizableSidebar behavior (drag resize + collapse + persisted width/state)
• StickyRegion utility (header/subheader/action bars with offset and z-index contracts)
• Responsive visibility utilities (Show, Hide, breakpoint-aware rendering helpers)

Layout hardening and consistency

• Define layout breakpoint contracts and tokenized spacing scale for app shells and page templates
• Verify SSR/hydration stability for responsive layout switching
• Add keyboard/a11y checks for collapsible/resizable navigation regions
• Add docs recipes: dashboard shell, settings shell, analytics shell, and mobile adaptive shell
• Add visual regression scenarios for major layout presets and breakpoint transitions

P1.16 Catalog delta parity (foundation and utility components)

Goal: close remaining catalog-level gaps for foundation, utility, and compositional components that are commonly available in mature Vue UI libraries.

Foundation and provider layer

• ThemeProvider component/API (local theme scope overrides per subtree)
• DefaultsProvider component/API (local default prop policies per subtree)
• LocaleProvider component/API (local i18n scope overrides)
• NoSsr utility component (client-only rendering boundary)
• MainLayoutRegion primitive (main area contract for shell composition)
• SystemBar component (global top status/utility strip)

Navigation and surface utilities

• BottomNavigation component (mobile-first primary navigation)
• Sheet component (generic elevated/flat container surface with variants)
• Window / pager container component (stateful pane switching and transitions)
• SlideGroup component (scrollable chip/tab/button group navigation)
• SnackbarQueue behavior (queued toast/snackbar orchestration)

Input and form composition helpers

• AvatarGroup component (overlap/stack/grouped avatar patterns)
• FloatLabel utility (floating label composition for inputs/selects)
• IftaLabel utility (in-field top-aligned label pattern support)
• IconField and InputIcon helpers (consistent icon slots/placement contracts)
• SelectionControl and SelectionControlGroup primitives (shared checkbox/radio/switch base behavior)
• ToggleButton component parity (binary action toggle separate from segmented control)

Interaction and content helpers

• Hover utility wrapper (hover state exposure with keyboard parity constraints)
• Hotkey utility component/composable (scoped shortcuts with accessibility-safe defaults)
• Kbd component (keyboard key visual tokens in docs/UI)
• CodeBlock component (syntax-highlighted display with copy/action slots)
• Lazy utility component (deferred mount/render for heavy subtree content)
• Parallax component (optional decorative motion container with reduced-motion compliance)
• Validation utility contracts (shared validation-state primitives and message wiring)
• PassThrough utility contracts (part-level prop/attr forwarding hooks for deep customization)

Delivery waves

MVP wave (required for immediate product impact):

• ThemeProvider
• DefaultsProvider
• LocaleProvider
• NoSsr
• BottomNavigation
• Sheet
• Window
• AvatarGroup
• FloatLabel
• IconField / InputIcon
• ToggleButton
• CodeBlock

Next wave (high leverage after MVP):

• SystemBar
• SlideGroup
• SnackbarQueue
• SelectionControl / SelectionControlGroup
• Hotkey
• Lazy
• Validation
• PassThrough

Later wave (specialized/optional utility coverage):

• MainLayoutRegion
• IftaLabel
• Hover
• Kbd
• Parallax

Catalog delta acceptance criteria:

• Every new item is added to docs/audits/component-catalog-mapping.md in the same PR.
• For aliases/equivalents, document mapping rationale and API differences.
• Alias-only items are explicitly mapped to canonical package ownership in rollout/API package specs.
• Components classified as not planned include explicit product rationale.

P2 (Scaling and Adoption)

P2.1 Release discipline

• Add bundle-size tracking per release
• Add and enforce semver checklist
• Add deprecation policy
• Add migration guide template
• Define component-level breaking-change rules and examples
• Add release gate: catalog mapping sync required before versioned release (docs/contributing/semver-release-checklist.md)

P2.2 Governance

• Add contribution guide focused on API consistency
• Add "what belongs in core" policy
• Add PR review checklist item for component catalog parity impact (docs/contributing/testing.md)
• Define recurring catalog audit cadence (monthly + pre-release) in mapping doc
• Add anti-duplicate component policy and PR gate (canonical component per functional domain)
• Create initial overlap triage matrix (docs/audits/component-catalog-mapping.md) with merge/split/alias decisions
• Define v1 alias-first scope reduction decisions to avoid duplicate implementation tracks

P2.3 Ecosystem support

Documentation platform and deployment:

• Add dedicated docs app (src/docs) with shell layout (header / sidebar / content / footer) inspired by Vue-style docs UX
• Add docs routing and sidebar navigation tree generated from documentation structure (pages + groups + prev/next links)
• Add markdown content pipeline to render docs from repository docs/ sources into docs app pages
• Add docs search/navigation quality baseline (active section highlight, mobile nav drawer, keyboard-accessible nav)
• Add docs build target (npm run build:docs) and output artifact strategy
• Add SSH deployment pipeline for docs artifacts (script + CI workflow + environment variable contract + rollback strategy)

P2.4 Security and robustness

• Add security checklist for input-rich components (link-like components, content rendering)
• Define sanitization/escaping recommendations and boundaries
• Add tests for critical unsafe-input scenarios
• Document secure usage patterns for consumers

P2.5 Competitive parity scorecard

Goal: measure practical competitiveness vs established Vue UI libraries with explicit scoring instead of binary "has component / no component".

Scoring model:

• Each tracked component gets 6 dimensions scored 0-2.
• 0 = missing, 1 = partial, 2 = parity-ready.
• Maximum per component: 12 points.

Dimensions (per component):

• Feature surface parity (core scenarios and key variants).
• API depth parity (props/events/slots and controlled patterns).
• A11y parity (keyboard + ARIA + focus behavior).
• Responsive parity (mobile/tablet/desktop behavior and touch interaction quality).
• Quality parity (tests, SSR/hydration checks, performance guardrails where relevant).
• Documentation parity (API docs + production recipe + migration notes if needed).

Library-level targets:

• >= 90% score for Must-have parity set.
• >= 85% score for High-leverage parity set.
• No Must-have parity component with A11y parity score below 2.
• No Must-have parity component with Responsive parity score below 2.
• No Must-have parity component with Documentation parity score below 2.
• Bundle-size and runtime performance regressions are tracked per release.

Release gates by maturity:

• "Competitive Beta": Must-have >= 90% and all safety gates in P2.4 complete.
• "v1 Competitive": Must-have >= 95% and High-leverage >= 90%.
• "v1 Competitive+" (optional): ICP-driven optional set reaches >= 80% for target segment.

Parity scope governance:

• Create initial component catalog mapping for target libraries: docs/audits/component-catalog-mapping.md.
• Maintain component catalog mapping each release: implemented / deferred / not planned with rationale.
• Create component compliance matrix for all public components: docs/audits/component-compliance-matrix.md.
• Maintain component compliance matrix in every PR for touched components.
• Create planned component compliance matrix for not-yet-implemented scope: docs/audits/planned-component-compliance-matrix.md.
• Maintain planned component compliance matrix and enforce transition Planned -> Implemented on release.