@mk-kit/ui 0.37.0 → 0.39.0

package/schematics/migrate-primeng/transform.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MK_STYLE_PATH = void 0;
+exports.transformTypeScript = transformTypeScript;
+exports.transformTemplate = transformTemplate;
+exports.transformAngularJson = transformAngularJson;
+exports.transformPackageJson = transformPackageJson;
+exports.renderReport = renderReport;
+/**
+ * Pure string transforms behind the `migrate-primeng` schematic. No devkit
+ * types here so they can be unit-tested on fixtures and reused by other
+ * tooling. Every function returns the new text plus what it did.
+ */
+const mapping_1 = require("./mapping");
+const MODULE_BY_PATH = new Map(mapping_1.MODULES.map((m) => [m.path, m]));
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function docsUrl(route) {
+    return route ? `${mapping_1.DOCS_BASE}${route}` : undefined;
+}
+/* ------------------------------------------------------------------------ */
+/* TypeScript                                                                */
+/* ------------------------------------------------------------------------ */
+const IMPORT_RE = /import\s*(type\s+)?\{([^}]*)\}\s*from\s*['"]primeng\/([\w-]+)['"];?[ \t]*\r?\n?/g;
+/**
+ * Rewrites `primeng/*` imports to `@mk-kit/ui`, renames the imported
+ * identifiers everywhere in the file, keeps unmapped symbols on their
+ * original import, and dedupes `imports: [...]` arrays.
+ */
+function transformTypeScript(source) {
+    const findings = [];
+    const mkNames = new Set();
+    const renames = new Map();
+    const keep = [];
+    let text = source;
+    let firstImportIndex = -1;
+    text = text.replace(IMPORT_RE, (whole, isType, names, path, offset) => {
+        const rule = MODULE_BY_PATH.get(path);
+        if (firstImportIndex === -1)
+            firstImportIndex = offset;
+        const symbols = names
+            .split(',')
+            .map((n) => n.trim())
+            .filter(Boolean);
+        const unmapped = [];
+        for (const raw of symbols) {
+            const [name, alias] = raw.split(/\s+as\s+/).map((s) => s.trim());
+            const target = rule?.symbols[name];
+            if (target) {
+                mkNames.add(target);
+                renames.set(alias ?? name, target);
+                add(findings, `import:primeng/${path}`, `${name} → ${target}`, 'rewrite', rule?.docs);
+            }
+            else {
+                unmapped.push(raw);
+                add(findings, `import:primeng/${path}`, `${name} (primeng/${path}) has no drop-in equivalent — kept`, rule ? 'manual' : 'unmapped', rule?.docs);
+            }
+        }
+        if (unmapped.length)
+            keep.push(`import ${isType ?? ''}{ ${unmapped.join(', ')} } from 'primeng/${path}';\n`);
+        if (rule?.note && symbols.some((s) => rule.symbols[s.split(/\s+as\s+/)[0].trim()])) {
+            add(findings, `note:primeng/${path}`, rule.note, 'manual', rule.docs);
+        }
+        return '';
+    });
+    if (firstImportIndex === -1)
+        return { text: source, changed: false, findings };
+    // Rename identifiers (whole words) — includes `imports: [...]` entries and injected services.
+    for (const [from, to] of renames) {
+        if (from === to)
+            continue;
+        text = text.replace(new RegExp(`\\b${escapeRe(from)}\\b`, 'g'), to);
+    }
+    // Dedupe entries inside `imports: [ ... ]` arrays (several PrimeNG symbols map to one class).
+    text = text.replace(/imports:\s*\[([^\]]*)\]/g, (whole, inner) => {
+        const seen = new Set();
+        const items = inner
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s && !seen.has(s) && seen.add(s));
+        const multiline = inner.includes('\n');
+        return multiline ? `imports: [\n    ${items.join(',\n    ')},\n  ]` : `imports: [${items.join(', ')}]`;
+    });
+    // Insert the mk-kit import where the first primeng import was, merging with an existing one.
+    const header = [...(keep.length ? keep : [])];
+    if (mkNames.size) {
+        const existing = /import\s*\{([^}]*)\}\s*from\s*['"]@mk-kit\/ui['"];?[ \t]*\r?\n?/;
+        const m = existing.exec(text);
+        if (m) {
+            const merged = new Set(m[1].split(',').map((s) => s.trim()).filter(Boolean));
+            for (const n of mkNames)
+                merged.add(n);
+            text = text.replace(existing, `import { ${[...merged].join(', ')} } from '@mk-kit/ui';\n`);
+        }
+        else {
+            header.unshift(`import { ${[...mkNames].join(', ')} } from '@mk-kit/ui';\n`);
+        }
+    }
+    text = text.slice(0, firstImportIndex) + header.join('') + text.slice(firstImportIndex);
+    // Service usage hints (MessageService / ConfirmationService bodies are not mechanical).
+    if (renames.has('MessageService')) {
+        text = text.replace(/(\n[ \t]*)([^\n]*\.add\(\s*\{[^\n]*severity[^\n]*)/g, '$1// mk-kit: MessageService.add({severity, summary, detail}) → toast.<severity>(detail, { title: summary })$1$2');
+    }
+    if (renames.has('ConfirmationService')) {
+        text = text.replace(/(\n[ \t]*)([^\n]*\.confirm\(\s*\{[^\n]*)/g, '$1// mk-kit: ConfirmationService.confirm({...}) → await dialog.confirm({ title, message, tone }) returns boolean$1$2');
+    }
+    // Inline templates get the template pass too.
+    const tpl = transformTemplate(text, true);
+    text = tpl.text;
+    findings.push(...tpl.findings);
+    return { text, changed: text !== source, findings };
+}
+/* ------------------------------------------------------------------------ */
+/* Templates                                                                 */
+/* ------------------------------------------------------------------------ */
+/** Longest selectors first so `p-inputgroupaddon` is not eaten by `p-inputgroup`. */
+const ELEMENT_RULES = mapping_1.SELECTORS.filter((r) => r.kind === 'element').sort((a, b) => b.from.length - a.from.length);
+const ATTRIBUTE_RULES = mapping_1.SELECTORS.filter((r) => r.kind === 'attribute').sort((a, b) => b.from.length - a.from.length);
+function noteComment(rule, inline) {
+    const text = `mk-kit: ${rule.from} → ${rule.to ?? 'manual'} — ${rule.note ?? ''}`.trim();
+    // Inside a TS template literal `-->` is fine; keep one comment style everywhere.
+    return inline ? `<!-- ${text} -->` : `<!-- ${text} -->`;
+}
+function renameAttrs(openTag, attrs) {
+    if (!attrs)
+        return openTag;
+    let out = openTag;
+    for (const [from, to] of Object.entries(attrs)) {
+        const re = new RegExp(`(\\s)${escapeRe(from)}(?=[\\s=>/])`, 'g');
+        out = out.replace(re, (_m, ws) => (to === null ? ws.trimEnd() : `${ws}${to}`));
+    }
+    return out;
+}
+/**
+ * Rewrites PrimeNG selectors in a template (an .html file, or a whole .ts file
+ * when `inline` — only `<p-…` tags and known attribute tokens are touched).
+ */
+function transformTemplate(source, inline = false) {
+    const findings = [];
+    let text = source;
+    for (const rule of ELEMENT_RULES) {
+        const open = new RegExp(`<${escapeRe(rule.from)}(?=[\\s>/])`, 'g');
+        const close = new RegExp(`</${escapeRe(rule.from)}\\s*>`, 'g');
+        const matches = text.match(open);
+        if (!matches)
+            continue;
+        const n = matches.length;
+        if (rule.to) {
+            // Rename open/close tags, then attributes on each opening tag.
+            text = text.replace(open, `<${rule.to}`).replace(close, `</${rule.to}>`);
+            if (rule.attrs) {
+                const tagRe = new RegExp(`<${escapeRe(rule.to)}(\\s[^>]*)?>`, 'g');
+                text = text.replace(tagRe, (tag) => renameAttrs(tag, rule.attrs));
+            }
+            add(findings, `element:${rule.from}`, `<${rule.from}> → <${rule.to}>`, 'rewrite', rule.docs, n);
+            if (rule.manual && rule.note) {
+                text = insertNote(text, `<${rule.to}`, noteComment(rule, inline));
+                add(findings, `manual:${rule.from}`, rule.note, 'manual', rule.docs, n);
+            }
+        }
+        else {
+            text = insertNote(text, `<${rule.from}`, noteComment(rule, inline));
+            add(findings, `element:${rule.from}`, rule.note ?? 'no drop-in equivalent', 'unmapped', rule.docs, n);
+        }
+    }
+    for (const rule of ATTRIBUTE_RULES) {
+        // Attribute token forms: `pButton`, `[pTooltip]="…"`, `pTooltip="…"`.
+        const token = new RegExp(`(?<=[\\s\\[])${escapeRe(rule.from)}(?=[\\s=\\]>/])`, 'g');
+        const matches = text.match(token);
+        if (!matches)
+            continue;
+        const n = matches.length;
+        if (rule.to) {
+            text = text.replace(token, rule.to);
+            if (rule.attrs) {
+                const tagRe = new RegExp(`<[a-zA-Z][^>]*\\b${escapeRe(rule.to)}\\b[^>]*>`, 'g');
+                text = text.replace(tagRe, (tag) => renameAttrs(tag, rule.attrs));
+            }
+            add(findings, `attr:${rule.from}`, `${rule.from} → ${rule.to}`, 'rewrite', rule.docs, n);
+            if (rule.manual && rule.note) {
+                text = insertNoteBeforeTagWith(text, rule.to, noteComment(rule, inline));
+                add(findings, `manual:${rule.from}`, rule.note, 'manual', rule.docs, n);
+            }
+        }
+        else {
+            text = insertNoteBeforeTagWith(text, rule.from, noteComment(rule, inline));
+            add(findings, `attr:${rule.from}`, rule.note ?? 'no drop-in equivalent', 'unmapped', rule.docs, n);
+        }
+    }
+    return { text, changed: text !== source, findings };
+}
+/** Insert `note` once, right before the first occurrence of `needle` (keeps indentation). */
+function insertNote(text, needle, note) {
+    if (text.includes(note))
+        return text;
+    const i = text.indexOf(needle);
+    if (i === -1)
+        return text;
+    const lineStart = text.lastIndexOf('\n', i) + 1;
+    const indent = text.slice(lineStart, i).match(/^[ \t]*$/) ? text.slice(lineStart, i) : '';
+    return indent ? text.slice(0, lineStart) + indent + note + '\n' + text.slice(lineStart) : text.slice(0, i) + note + ' ' + text.slice(i);
+}
+/** Insert `note` once before the first tag that carries `attr`. */
+function insertNoteBeforeTagWith(text, attr, note) {
+    if (text.includes(note))
+        return text;
+    const re = new RegExp(`<[a-zA-Z][^>]*(?<=[\\s\\[])${escapeRe(attr)}(?=[\\s=\\]>/])`);
+    const m = re.exec(text);
+    if (!m)
+        return text;
+    return insertNote(text, m[0], note);
+}
+/* ------------------------------------------------------------------------ */
+/* Workspace files                                                           */
+/* ------------------------------------------------------------------------ */
+exports.MK_STYLE_PATH = 'node_modules/@mk-kit/ui/styles/mk-kit.css';
+/** Remove PrimeNG / primeicons / primeflex style entries from every project's `styles`; add the mk-kit theme. */
+function transformAngularJson(source) {
+    const findings = [];
+    let json;
+    try {
+        json = JSON.parse(source);
+    }
+    catch {
+        return { text: source, changed: false, findings };
+    }
+    let changed = false;
+    for (const project of Object.values(json.projects ?? {})) {
+        const options = project?.architect?.build?.options;
+        if (!options || !Array.isArray(options.styles))
+            continue;
+        const before = options.styles.length;
+        options.styles = options.styles.filter((s) => {
+            const p = typeof s === 'string' ? s : s?.input ?? '';
+            return !/prime(ng|icons|flex|uix)/i.test(p);
+        });
+        if (options.styles.length !== before) {
+            changed = true;
+            add(findings, 'styles:primeng', `removed ${before - options.styles.length} PrimeNG/primeicons style entries`, 'rewrite', '/theming', before - options.styles.length);
+        }
+        const has = options.styles.some((s) => (typeof s === 'string' ? s : s?.input ?? '').includes('@mk-kit/ui/styles'));
+        if (!has) {
+            options.styles.unshift(exports.MK_STYLE_PATH);
+            changed = true;
+            add(findings, 'styles:mk-kit', `added ${exports.MK_STYLE_PATH}`, 'rewrite', '/theming');
+        }
+    }
+    return { text: changed ? JSON.stringify(json, null, 2) + '\n' : source, changed, findings };
+}
+/** Drop PrimeNG packages from dependencies and make sure @mk-kit/ui is present. */
+function transformPackageJson(source, packages, mkVersion = '^0.38.0') {
+    const findings = [];
+    let json;
+    try {
+        json = JSON.parse(source);
+    }
+    catch {
+        return { text: source, changed: false, findings };
+    }
+    let changed = false;
+    for (const field of ['dependencies', 'devDependencies']) {
+        const deps = json[field];
+        if (!deps)
+            continue;
+        for (const p of packages) {
+            if (p in deps) {
+                delete deps[p];
+                changed = true;
+                add(findings, 'package:remove', `removed ${p} from ${field}`, 'rewrite');
+            }
+        }
+    }
+    json.dependencies ??= {};
+    if (!json.dependencies['@mk-kit/ui']) {
+        json.dependencies['@mk-kit/ui'] = mkVersion;
+        changed = true;
+        add(findings, 'package:add', `added @mk-kit/ui ${mkVersion}`, 'rewrite');
+    }
+    return { text: changed ? JSON.stringify(json, null, 2) + '\n' : source, changed, findings };
+}
+function add(findings, rule, message, kind, docs, count = 1) {
+    const existing = findings.find((f) => f.rule === rule && f.message === message);
+    if (existing)
+        existing.count += count;
+    else
+        findings.push({ rule, message, kind, docs: docsUrl(docs), count });
+}
+/** Markdown report of a whole run. */
+function renderReport(files, options) {
+    const all = files.flatMap((f) => f.findings.map((x) => ({ ...x, file: f.path })));
+    const changed = files.filter((f) => f.changed);
+    const byKind = (kind) => all.filter((f) => f.kind === kind);
+    const sum = (list) => list.reduce((n, f) => n + f.count, 0);
+    const lines = [];
+    lines.push('# PrimeNG → mk-kit migration report', '');
+    lines.push(`${options.dryRun ? '**Dry run** — nothing was written. ' : ''}Scanned ${options.scanned} files, ${options.dryRun ? 'would change' : 'changed'} ${changed.length}.`, '');
+    lines.push(`- Automatic rewrites: **${sum(byKind('rewrite'))}**`);
+    lines.push(`- Needs a manual touch: **${sum(byKind('manual'))}**`);
+    lines.push(`- No mk-kit equivalent: **${sum(byKind('unmapped'))}**`, '');
+    lines.push('## Rewrites', '');
+    const rewrites = group(byKind('rewrite'));
+    lines.push(...(rewrites.length ? rewrites.map(([msg, n]) => `- ${msg} ×${n}`) : ['- (none)']), '');
+    lines.push('## Manual steps', '', 'Look for `<!-- mk-kit: … -->` and `// mk-kit:` comments in the changed files.', '');
+    const manual = group(byKind('manual'), true);
+    lines.push(...(manual.length ? manual.map(([msg, n, docs]) => `- ${msg} ×${n}${docs ? ` — [docs](${docs})` : ''}`) : ['- (none)']), '');
+    lines.push('## Not available in mk-kit', '');
+    const unmapped = group(byKind('unmapped'), true);
+    lines.push(...(unmapped.length ? unmapped.map(([msg, n, docs]) => `- ${msg} ×${n}${docs ? ` — closest: [docs](${docs})` : ''}`) : ['- (none)']), '');
+    lines.push('## Files', '');
+    lines.push(...(changed.length ? changed.map((f) => `- \`${f.path}\` — ${f.findings.map((x) => `${x.rule}×${x.count}`).join(', ')}`) : ['- (none)']), '');
+    lines.push('## Next', '');
+    lines.push('1. Run `ng build` and fix the remaining template errors — most are the `<!-- mk-kit -->` notes above.', '2. Replace `MessageService.add(...)` calls with `MkToastService` and `ConfirmationService.confirm(...)` with `await MkDialogService.confirm(...)`.', '3. Icons: `pi pi-*` classes → `<mk-icon name="…" />` (see https://mk-kit.dev/components/icon).', `4. Theme: \`--mk-*\` tokens replace the PrimeNG preset — https://mk-kit.dev/theming.`, '');
+    return lines.join('\n');
+}
+function group(list, withDocs = false) {
+    const map = new Map();
+    for (const f of list) {
+        const key = f.message;
+        const cur = map.get(key) ?? [0, f.docs];
+        cur[0] += f.count;
+        map.set(key, cur);
+    }
+    return [...map.entries()].map(([msg, [n, docs]]) => [msg, n, withDocs ? docs : undefined]);
+}

package/types/mk-kit-ui-core.d.ts

@@ -973,6 +973,10 @@ interface MkI18nStrings {
     chatToolDone: string;
     /** Chat: tool call failed. */
     chatToolError: string;
+    /** Dynamic form: add an item to an array field. */
+    dynamicFormAdd: string;
+    /** Dynamic form: remove one item of an array field (index is 1-based). */
+    dynamicFormRemove: (index: number) => string;
     /** Query builder: accessible name of the whole builder. */
     queryBuilderLabel: string;
     queryAddRule: string;

package/types/mk-kit-ui-dynamic-form.d.ts

@@ -0,0 +1,305 @@
+import { ValidatorFn, AbstractControl, FormGroup, FormControl, FormArray } from '@angular/forms';
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+/**
+ * Field kinds `mk-dynamic-form` renders out of the box. Each maps to one
+ * mk-kit control; `custom` renders a projected `mkDynamicField` template.
+ */
+type MkDynamicFieldType = 'text' | 'email' | 'password' | 'url' | 'tel' | 'search' | 'textarea' | 'number' | 'currency' | 'date' | 'time' | 'datetime' | 'select' | 'multi-select' | 'autocomplete' | 'radio' | 'toggle' | 'checkbox' | 'switch' | 'slider' | 'rating' | 'color' | 'tags' | 'phone' | 'file' | 'code' | 'custom';
+/** One option of a select / radio / toggle / autocomplete field. */
+interface MkDynamicOption {
+    label: string;
+    value: unknown;
+    disabled?: boolean;
+}
+/**
+ * Declarative validators — plain data so a schema can be stored as JSON.
+ * `custom` takes Angular validator functions for anything else.
+ */
+interface MkDynamicValidators {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    /** A RegExp or its source string. */
+    pattern?: string | RegExp;
+    email?: boolean;
+    /** Angular validator functions appended after the declarative ones. */
+    custom?: ValidatorFn[];
+}
+/**
+ * A serialisable condition over the form value (dotted paths reach into
+ * groups: `address.country`). Combine with `and` / `or`; a function is the
+ * escape hatch for TypeScript-only schemas.
+ */
+type MkDynamicCondition = {
+    field: string;
+    eq?: unknown;
+    neq?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
+    truthy?: boolean;
+    empty?: boolean;
+} | {
+    and: MkDynamicCondition[];
+} | {
+    or: MkDynamicCondition[];
+} | {
+    not: MkDynamicCondition;
+} | ((value: Record<string, unknown>) => boolean);
+/** Properties shared by every field that holds a value. */
+interface MkDynamicFieldBase {
+    /** Key in the form value. */
+    key: string;
+    type: MkDynamicFieldType;
+    label?: string;
+    hint?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /** Initial value when the form (or a new array item) is created. */
+    default?: unknown;
+    validators?: MkDynamicValidators;
+    /** Options for select / multi-select / radio / toggle / autocomplete. */
+    options?: readonly MkDynamicOption[];
+    /**
+     * Extra inputs forwarded to the underlying control — the subset each type
+     * understands (`rows`, `min`, `max`, `step`, `currency`, `accept`,
+     * `multiple`, `swatches`, `language`, …). See the docs table.
+     */
+    props?: Record<string, unknown>;
+    /** Grid columns (1–12) the field spans. Default: the form's `columns` split. */
+    span?: number;
+    /** Render (and enable) only when the condition holds. Hidden fields are excluded from the value. */
+    showWhen?: MkDynamicCondition;
+    /** Disable while the condition holds. */
+    disabledWhen?: MkDynamicCondition;
+}
+/** A nested object: its fields become a child `FormGroup` under `key`. */
+interface MkDynamicGroup {
+    type: 'group';
+    key: string;
+    label?: string;
+    hint?: string;
+    fields: MkDynamicField[];
+    span?: number;
+    /** Columns for the group's own grid (default: inherits the form's). */
+    columns?: number;
+    showWhen?: MkDynamicCondition;
+    disabledWhen?: MkDynamicCondition;
+}
+/** A list of objects: a `FormArray` of groups with add / remove controls. */
+interface MkDynamicArray {
+    type: 'array';
+    key: string;
+    label?: string;
+    hint?: string;
+    /** Fields of one item. */
+    fields: MkDynamicField[];
+    min?: number;
+    max?: number;
+    addLabel?: string;
+    /** Initial items (each is patched over the item defaults). */
+    default?: Record<string, unknown>[];
+    span?: number;
+    columns?: number;
+    showWhen?: MkDynamicCondition;
+    disabledWhen?: MkDynamicCondition;
+}
+/** A heading + description with no value of its own. */
+interface MkDynamicSection {
+    type: 'section';
+    label: string;
+    hint?: string;
+    span?: number;
+    showWhen?: MkDynamicCondition;
+}
+type MkDynamicField = MkDynamicFieldBase | MkDynamicGroup | MkDynamicArray | MkDynamicSection;
+/** The whole form. */
+interface MkDynamicSchema {
+    fields: MkDynamicField[];
+    /** Default number of columns fields are laid out in (1–12). Default 1. */
+    columns?: number;
+}
+declare function mkIsGroup(f: MkDynamicField): f is MkDynamicGroup;
+declare function mkIsArray(f: MkDynamicField): f is MkDynamicArray;
+declare function mkIsSection(f: MkDynamicField): f is MkDynamicSection;
+declare function mkIsValueField(f: MkDynamicField): f is MkDynamicFieldBase;
+
+/** The empty value a field type starts with when no `default` is given. */
+declare function mkDynamicEmptyValue(field: MkDynamicFieldBase): unknown;
+/** Default value object of a field list (groups nested, arrays as item lists). */
+declare function mkDynamicDefaults(fields: readonly MkDynamicField[]): Record<string, unknown>;
+/** Angular validators for one value field, from its declarative `validators` + `required`. */
+declare function mkDynamicValidators(field: MkDynamicFieldBase): ValidatorFn[];
+/** Build the `FormControl` / `FormGroup` / `FormArray` for one field. */
+declare function mkDynamicControl(field: MkDynamicField, value?: unknown): AbstractControl;
+/** A `FormGroup` for a field list; `value` (partial) overrides the defaults. */
+declare function mkDynamicGroup(fields: readonly MkDynamicField[], value?: Record<string, unknown>): FormGroup;
+/** Build the reactive form of a whole schema. */
+declare function mkDynamicForm(schema: MkDynamicSchema, value?: Record<string, unknown>): FormGroup;
+/**
+ * Evaluate a condition against a form value. `value` is normally the whole
+ * form value; inside an array item the item's own value is used, with the
+ * root available under `$root`.
+ */
+declare function mkDynamicCondition(cond: MkDynamicCondition | undefined, value: Record<string, unknown>): boolean;
+/** Depth-first list of every value field with its dotted path. */
+declare function mkDynamicFlatten(fields: readonly MkDynamicField[], prefix?: string): Array<{
+    path: string;
+    field: MkDynamicFieldBase | MkDynamicGroup | MkDynamicArray;
+}>;
+/** Column span a field takes in a grid of `columns`. */
+declare function mkDynamicSpan(field: MkDynamicField, columns: number): number;
+
+/** Context handed to a custom field template. */
+interface MkDynamicFieldContext {
+    $implicit: MkDynamicFieldBase;
+    field: MkDynamicFieldBase;
+    /** The field's `FormControl` — bind it with `[formControl]`. */
+    control: FormControl;
+    /** The current value of the whole form (or array item). */
+    value: Record<string, unknown>;
+}
+/**
+ * Registers a renderer for a custom field type:
+ *
+ * ```html
+ * <mk-dynamic-form [schema]="schema">
+ *   <ng-template mkDynamicField="signature" let-field let-control="control">
+ *     <mk-signature-pad [formControl]="control" />
+ *   </ng-template>
+ * </mk-dynamic-form>
+ * ```
+ *
+ * A field `{ type: 'custom', key: 'sig', props: { renderer: 'signature' } }`
+ * (or any built-in `type` you want to override) then renders this template
+ * inside the usual `mk-form-field`.
+ */
+declare class MkDynamicFieldDef {
+    /** The type (or `props.renderer` name) this template renders. */
+    readonly mkDynamicField: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<MkDynamicFieldContext>;
+    static ngTemplateContextGuard(_dir: MkDynamicFieldDef, ctx: unknown): ctx is MkDynamicFieldContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicFieldDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkDynamicFieldDef, "ng-template[mkDynamicField]", never, { "mkDynamicField": { "alias": "mkDynamicField"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Renders one field list (the root, a group, or one array item) as a grid.
+ * Internal — projected by {@link MkDynamicForm}; recursive for groups/arrays.
+ */
+declare class MkDynamicFields {
+    private readonly root;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    readonly fields: _angular_core.InputSignal<readonly MkDynamicField[]>;
+    readonly group: _angular_core.InputSignal<FormGroup<any>>;
+    readonly columns: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Value the conditions of this level are evaluated against. */
+    readonly scope: _angular_core.InputSignal<Record<string, unknown>>;
+    protected readonly labelPosition: _angular_core.Signal<any>;
+    protected readonly size: _angular_core.Signal<any>;
+    protected control(f: MkDynamicField): AbstractControl;
+    protected formGroup(f: MkDynamicGroup): FormGroup;
+    protected formArray(f: MkDynamicArray): FormArray<FormGroup>;
+    protected isVisible(f: MkDynamicField): boolean;
+    protected span(f: MkDynamicField): number;
+    protected columnsOf(f: MkDynamicGroup | MkDynamicArray): number;
+    protected isGroup: typeof mkIsGroup;
+    protected isArray: typeof mkIsArray;
+    protected isSection: typeof mkIsSection;
+    protected isValue: typeof mkIsValueField;
+    /** Custom template for a value field, if one is registered. */
+    protected customTemplate(f: MkDynamicFieldBase): TemplateRef<MkDynamicFieldContext> | null;
+    protected customContext(f: MkDynamicFieldBase): MkDynamicFieldContext;
+    /** `props.x` with a typed default. */
+    protected p(f: MkDynamicFieldBase, key: string, fallback: unknown): any;
+    protected inputType(f: MkDynamicFieldBase): string;
+    protected itemScope(f: MkDynamicArray, index: number): Record<string, unknown>;
+    protected canAdd(f: MkDynamicArray): boolean;
+    protected canRemove(f: MkDynamicArray): boolean;
+    protected addItem(f: MkDynamicArray): void;
+    protected removeItem(f: MkDynamicArray, index: number): void;
+    protected trackItem(index: number, item: FormGroup): FormGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicFields, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDynamicFields, "mk-dynamic-fields", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "group": { "alias": "group"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Dynamic form — renders a form from a JSON schema and manages one reactive
+ * `FormGroup` for it. Every value field renders inside `mk-form-field`, so
+ * labels, hints, required marks and localised validation messages come from
+ * the schema alone.
+ *
+ * ```html
+ * <mk-dynamic-form [schema]="schema" [(value)]="user" (formSubmit)="save($event)">
+ *   <button mkButton type="submit">Save</button>
+ * </mk-dynamic-form>
+ * ```
+ *
+ * ```ts
+ * schema: MkDynamicSchema = {
+ *   columns: 2,
+ *   fields: [
+ *     { key: 'name', type: 'text', label: 'Name', required: true },
+ *     { key: 'role', type: 'select', label: 'Role', options: roles },
+ *     { key: 'company', type: 'text', label: 'Company', showWhen: { field: 'role', eq: 'b2b' } },
+ *   ],
+ * };
+ * ```
+ *
+ * - Hidden fields (`showWhen` false) are disabled, so `value` only carries
+ *   what the user can see; `form.getRawValue()` has everything.
+ * - `form` is the live `FormGroup` for anything the schema does not cover.
+ * - Custom field types: project an `ng-template[mkDynamicField]`.
+ */
+declare class MkDynamicForm {
+    private readonly destroyRef;
+    /** The schema. Changing it rebuilds the form (values of surviving keys are kept). */
+    readonly schema: _angular_core.InputSignal<MkDynamicSchema>;
+    /** Two-way form value (visible, enabled fields only). */
+    readonly value: _angular_core.ModelSignal<Record<string, unknown>>;
+    /** Disable every control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Label placement forwarded to every `mk-form-field`. */
+    readonly labelPosition: _angular_core.InputSignal<"top" | "float">;
+    /** Control size forwarded to the fields. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Emits the value when the form is submitted and valid. */
+    readonly formSubmit: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    /** Emits when a submit is attempted while invalid (every control is marked touched). */
+    readonly invalidSubmit: _angular_core.OutputEmitterRef<FormGroup<any>>;
+    private readonly defs;
+    private readonly formSignal;
+    private readonly formValue;
+    private subscription;
+    private applying;
+    /** The live reactive form. */
+    get form(): FormGroup;
+    protected readonly formRef: _angular_core.Signal<FormGroup<any>>;
+    /** Value including disabled fields — what conditions are evaluated against. */
+    protected readonly scope: _angular_core.Signal<Record<string, unknown>>;
+    protected readonly columns: _angular_core.Signal<number>;
+    protected readonly fields: _angular_core.Signal<MkDynamicField[]>;
+    /** `true` while every control passes validation. */
+    readonly valid: _angular_core.Signal<boolean>;
+    constructor();
+    private attach;
+    /** Re-evaluate conditions and push the form value to `value`. @internal */
+    sync(): void;
+    private applyConditions;
+    /** Template registered for a custom type / renderer name. @internal */
+    templateFor(name: string): TemplateRef<MkDynamicFieldContext> | null;
+    /** Patch part of the value. */
+    patch(value: Record<string, unknown>): void;
+    /** Reset to the schema defaults (or the given value). */
+    reset(value?: Record<string, unknown>): void;
+    /** Mark every control touched so validation messages show. */
+    touchAll(): void;
+    protected onSubmit(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDynamicForm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDynamicForm, "mk-dynamic-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "formSubmit": "formSubmit"; "invalidSubmit": "invalidSubmit"; }, ["defs"], ["*"], true, never>;
+}
+
+export { MkDynamicFieldDef, MkDynamicFields, MkDynamicForm, mkDynamicCondition, mkDynamicControl, mkDynamicDefaults, mkDynamicEmptyValue, mkDynamicFlatten, mkDynamicForm, mkDynamicGroup, mkDynamicSpan, mkDynamicValidators, mkIsArray, mkIsGroup, mkIsSection, mkIsValueField };
+export type { MkDynamicArray, MkDynamicCondition, MkDynamicField, MkDynamicFieldBase, MkDynamicFieldContext, MkDynamicFieldType, MkDynamicGroup, MkDynamicGroup as MkDynamicGroupField, MkDynamicOption, MkDynamicSchema, MkDynamicSection, MkDynamicValidators };