@modyra/angular 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lorenzo muscherà
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,364 @@
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/assets/brand/readme-banner-dark.png">
+  <img src="docs/assets/brand/readme-banner-light.png" alt="Modyra — Model once. Render anywhere.">
+</picture>
+
+# Modyra
+
+**Model once. Render anywhere.** A framework-agnostic, type-safe form
+engine with native bindings for Angular, React, Vue and Lit — one shared
+core, one shared headless widget layer, one shared theme package.
+
+- No `FormControl`, `FormGroup` or RxJS — form state is signals and `computed`s
+- Compile-time checked field bindings: `[field]="form.f.email"`, typos don't compile
+- Sync, async (debounced, cancellable, cross-field) and form-level validation
+- Typed field arrays (`array()`) for repeatable rows — push/insert/remove/move
+- Drafts (autosave/restore), undo/redo, minimal-patch change tracking, devtools
+- Headless core or accessible ready-made controls — your design system or ours
+- Incremental Angular adoption through Reactive Forms interop (`mdyCva`)
+
+[![CI](https://github.com/modyra/modyra/actions/workflows/ci.yml/badge.svg)](https://github.com/modyra/modyra/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@modyra/angular)](https://www.npmjs.com/package/@modyra/angular)
+[![Angular](https://img.shields.io/badge/Angular-21%2B-red)](https://angular.dev)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue)](https://www.typescriptlang.org)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![GitHub Sponsors](https://img.shields.io/badge/Sponsor-GitHub-ea4aaa?style=flat&logo=github-sponsors)](https://github.com/sponsors/lorenzomusche)
+
+## Packages
+
+| Package                               | What it is                                                                                               | Peer deps              |
+| :------------------------------------ | :------------------------------------------------------------------------------------------------------- | :--------------------- |
+| [`@modyra/core`](packages/core)       | Framework-agnostic form engine: typed field trees, arrays, validation, drafts, undo/redo, i18n utilities | —                      |
+| [`@modyra/widgets`](packages/widgets) | Headless widget controllers + universal interaction/accessibility contract                               | —                      |
+| [`@modyra/angular`](packages/angular) | Angular binding on native signals — the most complete adapter (UI catalog, devtools, wizard, interop)    | `@angular/*` ≥21       |
+| [`@modyra/react`](packages/react)     | React binding via `useSyncExternalStore`                                                                 | `react` ≥18            |
+| [`@modyra/vue`](packages/vue)         | Vue binding on `@vue/reactivity`                                                                         | `@vue/reactivity` ≥3.4 |
+| [`@modyra/lit`](packages/lit)         | Lit binding — ReactiveController + themable form elements                                                | `lit` ≥3               |
+| [`@modyra/zod`](packages/zod)         | Framework-agnostic Zod adapter — schema-first typed forms                                                | `zod` ≥3.25            |
+| [`@modyra/styles`](packages/styles)   | CSS themes (`default`, `material`, `ios`, `ionic`, `base`) for every adapter                             | —                      |
+
+## The engine in 60 seconds (framework-agnostic)
+
+Everything below runs in plain TypeScript — Node, a CLI, a worker, a unit
+test, or any of the four framework adapters. No framework in sight:
+
+```ts
+import { createForm, field, group, required, email, min } from "@modyra/core";
+
+const form = createForm({
+  email: field("", [required(), email()]),
+  age: field<number | null>(null, [min(18)]),
+  address: group({ city: field("Rome"), zip: field("") }),
+});
+
+form.f.email.set("not-an-email");
+form.f.email.errors(); // ["Enter a valid email address"]
+form.getValue().address.city; // "Rome" — fully typed, typos don't compile
+```
+
+> **Validators are factories, not values:** write `required()`, not
+> `required` (Angular Reactive Forms muscle memory trips here — the
+> resulting TS error is easy to misread). Validation errors come back as
+> **arrays of message strings** (`["Name taken"]`), not `{ required: true }`
+> keyed objects. To stop at the first failing validator instead of
+> collecting all of them, use `composeFirst()` in place of `compose()`.
+
+## Real-world scenarios, handled by the engine
+
+These are the cases that make form code rot in production — nested data,
+repeatable rows, server round-trips, refreshes, "apply my changes only".
+Each one below is complete and runnable in plain TypeScript.
+
+### 1. Checkout: nested groups, repeatable line items, a coupon checked server-side
+
+An order form with an address group, a **typed array** of line items, a
+coupon validated against the server (re-checked automatically when the
+country changes), and server errors routed back to fields on submit.
+
+```ts
+import {
+  createForm,
+  field,
+  group,
+  array,
+  required,
+  min,
+  pattern,
+  crossField,
+  serverValidator,
+} from "@modyra/core";
+
+const form = createForm(
+  {
+    country: field("IT"),
+    shipping: group({
+      city: field("", [required()]),
+      zip: field("", [required(), pattern(/^\d{5}$/, "5 digits")]),
+    }),
+    // Typed repeatable rows: form.f.items.rows(), push/insert/remove/move
+    items: array(
+      group({
+        sku: field("", [required()]),
+        qty: field<number>(1, [min(1)]),
+      }),
+      { initial: [{ sku: "TSHIRT-BLK-M", qty: 2 }] },
+    ),
+    coupon: field(
+      "",
+      [],
+      serverValidator(
+        async (code, ctx) => {
+          if (!code) return null; // optional field — skip the call
+          // ctx.form reads the rest of the form; ctx.signal cancels stale calls
+          const res = await api.coupons.check(
+            code,
+            ctx.form.fieldValue("country"),
+            {
+              signal: ctx.signal,
+            },
+          );
+          return res.valid ? null : "Coupon not valid for your country";
+        },
+        {
+          dependsOn: ["country"], // country flips → coupon re-validates itself
+          debounceMs: 400,
+          timeoutMs: 5000, // never a "pending" that lasts forever
+        },
+      ),
+    ),
+  },
+  {
+    validators: [
+      // Form-level rule over the whole typed value
+      crossField(["items"], (v) =>
+        v.items.length === 0 ? "Add at least one item to the order" : null,
+      ),
+    ],
+  },
+);
+
+form.f.items.push({ sku: "MUG-WHT", qty: 1 });
+form.f.items.rows()[1].sku.errors(); // per-row, per-field errors
+form.f.items.remove(0);
+form.f.items.length(); // 1
+form.getValue().items[0].qty; // number — a typo here is a compile error
+
+const result = await form.submit(async (order) => {
+  const res = await api.orders.create(order);
+  if (!res.ok) {
+    // Server errors land on the matching field (or the form, with path: null)
+    return res.errors.map((e) => ({
+      path: e.field,
+      kind: "server",
+      message: e.message,
+    }));
+  }
+});
+```
+
+What the engine did for you: `items.0.sku`-style paths stay compile-checked;
+`state.valid()` includes per-row validators _and_ the form-level rule; the
+coupon re-checks itself when `country` flips and aborts the previous HTTP
+call when you keep typing; `state.pending()` covers every async run, so a
+submit button bound to `state.canSubmit()` can't fire mid-validation.
+
+### 2. A long insurance claim: survive refresh, undo mistakes, patch only what changed
+
+A 40-field claim form. The user refreshes mid-way (drafts), deletes the
+wrong paragraph (undo/redo), and your backend only wants the diff
+(`getChanges`).
+
+```ts
+import { createForm, field, group, required, minLength } from "@modyra/core";
+
+const form = createForm(
+  {
+    policyNumber: field("", [required()]),
+    incident: group({
+      date: field("", [required()]), // ISO yyyy-MM-dd
+      description: field("", [required(), minLength(30)]),
+    }),
+    iban: field("", [required()]),
+  },
+  {
+    // Autosave to localStorage every 500 ms of idle; restored on reload.
+    // Sensitive fields are masked in devtools and excluded from the draft.
+    draft: { key: "claim-form", exclude: ["iban"] },
+    history: true, // undo()/redo()
+  },
+);
+
+form.f.incident.description.set("The kitchen pipe burst and…");
+form.undo(); // oops — bring the paragraph back
+form.redo();
+
+form.getChanges(); // { incident: { description: "The kitchen pipe…" } }
+// → the minimal PATCH body, typed
+```
+
+Drafts are versioned envelopes with a 7-day TTL: File/BigInt values are
+refused, quota errors never crash the form, and `__proto__`-style paths in
+a tampered `localStorage` entry are discarded at restore.
+
+### 3. Schema-first: the backend already speaks Zod
+
+The validation contract lives in one Zod schema shared with your API — the
+form derives fields, initial values, validators and cross-field rules from
+it, arrays included:
+
+```ts
+import { z } from "zod";
+import { createZodForm } from "@modyra/zod";
+
+const passengerSchema = z.object({
+  fullName: z.string().min(1, "Required"),
+  infant: z.boolean(),
+});
+
+const bookingSchema = z.object({
+  flight: z.string().min(1, "Pick a flight"),
+  passengers: z.array(passengerSchema).min(1, "At least one passenger"),
+  contact: z.object({
+    email: z.string().email(),
+    phone: z.string().optional(),
+  }),
+});
+
+const form = createZodForm(bookingSchema);
+form.f.passengers.push({ fullName: "Ada Lovelace", infant: false });
+// z.array() → typed field array; .min(1) → array-level validator gating submit
+```
+
+`zod` is an _optional_ peer (`>=3.25`, Zod 4 supported): apps that don't
+use schemas never download it.
+
+## The same app, four frameworks
+
+The engine is identical everywhere — only the reactive binding and the
+rendering idiom change. A complete checkout form (nested groups, typed
+array rows, cancellable server validation, submit with server errors) is
+implemented end-to-end, side by side, in:
+
+- [Angular](docs/examples/angular.md) — `mdyForm` + the UI catalog, `@for` over `rows()`
+- [React](docs/examples/react.md) — `useMdyForm` / `useMdyField`, array rows with `.map()`
+- [Vue](docs/examples/vue.md) — `createVueForm` on `@vue/reactivity`
+- [Lit](docs/examples/lit.md) — `createLitForm` + `<mdy-*-field>` custom elements
+
+Adapter recipes, the four-primitive reactive contract and the Astro note:
+[Multi-framework architecture](docs/guides/multi-framework.md).
+
+## Why not Reactive Forms?
+
+Reactive Forms is official, mature and battle-tested — if that is what your
+team needs, keep it. This library trades ecosystem maturity for:
+compile-checked field paths, signal-based state (zoneless-friendly, no RxJS)
+and built-in async/cross-field validation, typed arrays, drafts, undo/redo
+and devtools.
+
+"No RxJS / no `@angular/forms`" means precisely: no runtime dependency, no
+Observables in the public API, none used internally. The optional `/interop`
+entry point is the single exception — it declares `@angular/forms` as an
+_optional_ peer for CVA-based migration.
+
+Full, honest comparison: [Compared with Reactive Forms](docs/guides/comparison-reactive-forms.md).
+
+## Layers
+
+```text
+   Typed API (mdyForm)    Declarative API    Dynamic JSON config
+            \                   |                   /
+                Shared Form Engine  (@modyra/core)
+                                |
+             Headless widget layer  (@modyra/widgets)
+                                |
+     Angular ─ React ─ Vue ─ Lit  (one native binding each)
+                                |
+        Headless integrations  or  UI catalogs + @modyra/styles themes
+```
+
+The form engine — typed field trees, arrays, validation, drafts, undo/redo —
+lives in [`@modyra/core`](packages/core), a zero-dependency package that
+runs in plain Node. [`@modyra/widgets`](packages/widgets) adds headless
+widget controllers and the interaction/accessibility contract shared by
+every renderer. Each adapter implements the same four-primitive reactive
+contract on its framework's native reactivity: Angular signals,
+`@vue/reactivity`, React's `useSyncExternalStore`, Lit's ReactiveController.
+
+## Angular entry points
+
+| Import                    | Contents                                  | Extra peer deps                  |
+| :------------------------ | :---------------------------------------- | :------------------------------- |
+| `@modyra/angular`         | Full bundle: adapter + UI + tools         | —                                |
+| `@modyra/angular/adapter` | Headless Angular adapter layer only       | —                                |
+| `@modyra/angular/ui`      | UI primitives and built-in renderers only | —                                |
+| `@modyra/angular/zod`     | `mdyFormFromSchema()`                     | `@modyra/zod` + `zod` (optional) |
+| `@modyra/angular/interop` | `mdyCva` for Reactive Forms               | `@angular/forms` (optional)      |
+
+## Documentation
+
+The full index lives in [docs/README.md](docs/README.md). The shortlist:
+
+- [Mental model](docs/guides/mental-model.md) — the state graph, field lifecycle, operation semantics
+- [Typed forms](docs/guides/typed-forms.md) — schema, handles, `patch`/`getChanges`, async validation, field arrays, undo/redo, **drafts (read the security note)**, wizard, Zod
+- [Usage modes](docs/guides/usage-modes.md) — declarative, explicit adapter, headless, validation semantics
+- [UI toolkit](docs/guides/ui-toolkit.md) — renderer catalog, enterprise select, dynamic forms, CSS tokens
+- [DevTools](docs/guides/devtools.md) — hotkey overlay, masking, production notes
+- [I18n](docs/guides/i18n.md) — UI strings (en/it/de/fr/es), date/time value models, localized parsing
+- [Reactive Forms interop](docs/guides/interop.md) · [Comparison](docs/guides/comparison-reactive-forms.md) · [Troubleshooting](docs/guides/troubleshooting.md)
+
+Project policies: [security](SECURITY.md) · [contributing](CONTRIBUTING.md) · [changelog](CHANGELOG.md)
+
+## Compatibility and status
+
+- **Angular 21+** — the engine relies on stable signal APIs (`linkedSignal`,
+  `effect` semantics, signal-based inputs/queries) shipped in recent majors;
+  older majors are not tested and not supported.
+- React ≥18, `@vue/reactivity` ≥3.4, Lit ≥3, `zod` ≥3.25 — each only for its
+  own adapter package.
+- TypeScript strict mode; the library compiles with `strict` and
+  `strictTemplates`.
+- Status: young library, actively developed, single maintainer. Unit and
+  type tests cover the core engine, every adapter and the widget layer
+  (`npm test`, `npm run test:core`, `npm run test:adapters`,
+  `npm run test:widgets`), plus a tree-shaking bundle check
+  (`npm run test:bundle`); browser, axe and visual tests are planned.
+  Pin your version and read release notes.
+
+## Examples
+
+`examples/{react,vue,lit}` implement the **same signup form** (name +
+email, shared validators, agnostic devtools panel) so the adapters can be
+compared side by side, with a runtime switcher across the shipped themes
+(default, Material, iOS, Ionic). They import the **built** `@modyra/*`
+packages from `node_modules` — the same artifacts users install, never the
+library sources.
+
+```bash
+npm run demo:angular   # Angular demo over the packaged build
+npm run demo:react     # http://localhost:4301
+npm run demo:vue       # http://localhost:4302
+npm run demo:lit       # http://localhost:4303
+```
+
+## Local development
+
+```bash
+pnpm install             # workspace deps use the workspace: protocol — use pnpm
+npm run build:lib        # core + widgets + zod + Angular library build
+npm run build:packages   # core + widgets + zod/vue/react/lit + styles
+npm start                # Angular demo app
+npm test                 # Angular unit + type tests
+npm run test:adapters    # zod/vue/react/lit node tests
+```
+
+## Brand
+
+Logo, palette and typography live in
+[`docs/assets/brand`](docs/assets/brand) — three soft modules (the
+adapters) around a shared negative space (the core).
+
+<img src="docs/assets/brand/palette.png" alt="Modyra palette — Indigo #7067FF, Violet #A855F7, Coral #FF6577, Night #0E0F16, Cloud #F8FAFC, Slate #94A3B8" width="420">
+
+## License
+
+MIT © [Lorenzo Muscherà](https://github.com/lorenzomusche)

package/fesm2022/modyra-angular-adapter.mjs

@@ -0,0 +1,19 @@
+export { MDY_DATE_LOCALE, MDY_DECLARATIVE_REGISTRY, MDY_FLOATING_LABELS_DEFAULT, MDY_FLOATING_LABELS_DENSITY_DEFAULT, MDY_FORM_ADAPTER, MDY_I18N_MESSAGES, MDY_INLINE_ERRORS, MdyDeclarativeAdapter, MdyTypedForm, angularReactivity, array, field, group, mdyForm, provideModyraLocale } from '@modyra/angular';
+
+/*
+ * Public API Surface of @modyra/angular/adapter.
+ *
+ * Headless Angular bindings over the framework-agnostic core engine:
+ * typed form model, declarative adapter, core form contracts and DI tokens.
+ * No renderer components and no theme assets.
+ *
+ * NOTE: this secondary entrypoint re-exports from @modyra/angular
+ * intentionally. ng-packagr secondary builds enforce rootDir boundaries,
+ * so direct imports from ../../src/... are not viable here.
+ */
+// Typed form (mdyForm)
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=modyra-angular-adapter.mjs.map

package/fesm2022/modyra-angular-interop.mjs

@@ -0,0 +1,145 @@
+import * as i0 from '@angular/core';
+import { inject, Injector, HostAttributeToken, signal, effect, untracked, forwardRef, Directive } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MDY_FORM_ADAPTER, MdyDeclarativeAdapter, MDY_DECLARATIVE_REGISTRY } from '@modyra/angular/adapter';
+
+/**
+ * Bridges any modyra renderer into classic Reactive Forms /
+ * `ngModel` — incremental adoption in existing codebases without an
+ * `<mdy-form>`:
+ *
+ * ```html
+ * <form [formGroup]="group">
+ *   <mdy-control-text mdyCva name="email" formControlName="email" label="Email" />
+ * </form>
+ * ```
+ *
+ * The directive provides a private single-field adapter on the element (the
+ * renderer resolves it instead of a surrounding `<mdy-form>`) and implements
+ * `ControlValueAccessor` on top of it: `writeValue` → field value,
+ * user edits → `onChange`, first blur → `onTouched`, `setDisabledState` →
+ * field `disabled`. Validation stays in Reactive Forms — bind your own
+ * error display to the `FormControl`, or mirror errors into the renderer
+ * with `aria-*` inputs.
+ */
+class MdyCvaDirective {
+    constructor() {
+        this.adapter = inject(MDY_FORM_ADAPTER);
+        this.injector = inject(Injector);
+        this.fieldName = inject(new HostAttributeToken("name"), { optional: true }) ?? "value";
+        this._disabled = signal(false, ...(ngDevMode ? [{ debugName: "_disabled" }] : /* istanbul ignore next */ []));
+        /** True while writeValue applies a model→view update (must not re-emit). */
+        this._writing = false;
+        this._onChange = () => undefined;
+        this._onTouched = () => undefined;
+        if (this.fieldName === "value" &&
+            typeof ngDevMode !== "undefined" &&
+            ngDevMode) {
+            console.warn('[modyra] mdyCva host has no "name" attribute — using the fallback field name "value".');
+        }
+        const state = this._state();
+        this.adapter.setDisabled(this.fieldName, this._disabled.asReadonly());
+        // View → model: propagate user edits, skipping writeValue echoes and
+        // the first run — emitting the initial value would mark the FormControl
+        // dirty at startup, violating the CVA contract (R21).
+        let first = true;
+        effect(() => {
+            const value = state.value();
+            untracked(() => {
+                if (first) {
+                    first = false;
+                    return;
+                }
+                if (this._writing)
+                    return;
+                this._onChange(value);
+            });
+        }, { injector: this.injector });
+        // First touch propagates the blur to Reactive Forms.
+        effect(() => {
+            const touched = state.touched();
+            untracked(() => {
+                if (touched)
+                    this._onTouched();
+            });
+        }, { injector: this.injector });
+    }
+    _state() {
+        const ref = this.adapter.getField(this.fieldName);
+        if (!ref) {
+            throw new Error(`[modyra] mdyCva could not create field "${this.fieldName}"`);
+        }
+        return ref();
+    }
+    writeValue(value) {
+        this._writing = true;
+        try {
+            this._state().value.set(value ?? null);
+        }
+        finally {
+            this._writing = false;
+        }
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this._disabled.set(isDisabled);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.18", ngImport: i0, type: MdyCvaDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.18", type: MdyCvaDirective, isStandalone: true, selector: "[mdyCva]", providers: [
+            {
+                provide: MDY_FORM_ADAPTER,
+                useFactory: () => new MdyDeclarativeAdapter(signal(undefined), signal("manual")),
+            },
+            {
+                provide: MDY_DECLARATIVE_REGISTRY,
+                useExisting: MDY_FORM_ADAPTER,
+            },
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => MdyCvaDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.18", ngImport: i0, type: MdyCvaDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[mdyCva]",
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: MDY_FORM_ADAPTER,
+                            useFactory: () => new MdyDeclarativeAdapter(signal(undefined), signal("manual")),
+                        },
+                        {
+                            provide: MDY_DECLARATIVE_REGISTRY,
+                            useExisting: MDY_FORM_ADAPTER,
+                        },
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => MdyCvaDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [] });
+
+/*
+ * Public API Surface of @modyra/angular/interop
+ *
+ * Interop with classic @angular/forms: the `mdyCva` directive makes every
+ * modyra renderer usable inside Reactive Forms / ngModel for
+ * incremental adoption. Requires the optional `@angular/forms` peer.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MdyCvaDirective };
+//# sourceMappingURL=modyra-angular-interop.mjs.map

package/fesm2022/modyra-angular-ui.mjs

@@ -0,0 +1,18 @@
+export { MDY_DEVTOOLS_HOTKEY, MDY_FLOATING_LABELS, MdyA11yAnnouncer, MdyBaseControl, MdyCalendarCellComponent, MdyCalendarComponent, MdyCalendarGridComponent, MdyCalendarHeaderComponent, MdyCheckboxComponent, MdyChipsDirective, MdyColorsComponent, MdyConditionalOptionsDirective, MdyControlComponent, MdyControlLabelComponent, MdyDatePickerComponent, MdyDateRangePickerComponent, MdyDevtoolsDirective, MdyDisabledDirective, MdyDynamicFormComponent, MdyEmailDirective, MdyErrorListComponent, MdyFileComponent, MdyFloatingLabelsDirective, MdyFormArrayComponent, MdyFormComponent, MdyFormWizardComponent, MdyFormsDevtoolsComponent, MdyFormsDevtoolsOverlayComponent, MdyFormsDevtoolsService, MdyGlassDirective, MdyIconComponent, MdyInlineErrorIconComponent, MdyInlineErrorsDirective, MdyLoadOptionsDirective, MdyMaxDirective, MdyMaxLengthDirective, MdyMinDirective, MdyMinLengthDirective, MdyMultiselectComponent, MdyNumberComponent, MdyOptionDirective, MdyOptionsAutoLoadingDirective, MdyOptionsOverlayControl, MdyOverlayControl, MdyPatternDirective, MdyPrefixDirective, MdyRadioGroupComponent, MdyRangeCalendarComponent, MdyRangeCalendarGridComponent, MdyRequiredDirective, MdySegmentedButtonComponent, MdySelectComponent, MdySliderComponent, MdySuffixDirective, MdySupportingTextDirective, MdyTextComponent, MdyTextareaComponent, MdyTimepickerComponent, MdyToggleComponent, MdyValidatorBaseDirective, MdyWizardStepComponent } from '@modyra/angular';
+
+/*
+ * Public API Surface of @modyra/angular/ui.
+ *
+ * Angular UI primitives and built-in renderers for modyra forms.
+ * This entry point intentionally excludes headless adapter contracts.
+ *
+ * NOTE: this secondary entrypoint re-exports from @modyra/angular
+ * intentionally. ng-packagr secondary builds enforce rootDir boundaries,
+ * so direct imports from ../../src/... are not viable here.
+ */
+// Form containers
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=modyra-angular-ui.mjs.map

package/fesm2022/modyra-angular-zod.mjs

@@ -0,0 +1,33 @@
+import { mdyForm } from '@modyra/angular/adapter';
+import { buildZodTree, buildZodRefinementValidator } from '@modyra/zod';
+
+/**
+ * Builds an Angular typed form from a `z.object()` schema — one source of
+ * truth for TypeScript types, validators, messages and required flags.
+ * See `@modyra/zod` for the shared semantics; bind the result with
+ * `[form]` and `[field]` exactly like `mdyForm()`.
+ */
+function mdyFormFromSchema(schema, options) {
+    const tree = buildZodTree(schema);
+    const refinementValidator = buildZodRefinementValidator(schema);
+    return mdyForm(tree, {
+        ...(options?.submitMode !== undefined && { submitMode: options.submitMode }),
+        ...(options?.injector !== undefined && { injector: options.injector }),
+        validators: [refinementValidator, ...(options?.validators ?? [])],
+    });
+}
+
+/*
+ * Public API Surface of @modyra/angular/zod
+ *
+ * Optional Zod adapter: derive a fully typed MdyTypedForm from a z.object()
+ * schema — types, validators, required flags and cross-field refinements
+ * from a single source of truth. Requires the `zod` peer (>= 3.25).
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { mdyFormFromSchema };
+//# sourceMappingURL=modyra-angular-zod.mjs.map