@koobiq/components 20.4.2 → 21.0.0

package/schematics/migrations/modal-dialog-semantics/README.md

@@ -0,0 +1,106 @@
+# modal-dialog-semantics
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21`
+(registered for `21.0.0-0`). Reports what the modal review changed for consumers: the members that
+disappeared or became protected, and the close controls that stopped being inert on the
+declarative path. It never writes to the tree.
+
+## Background
+
+The dialog is a real dialog now, and its two entry paths behave the same.
+
+| Member                                                                                                                                                                                            | Before | After       |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ----------- |
+| `transformOrigin`, `getKbqFooter()`, `getContainerClasses()`, `autoFocusedButtons`                                                                                                                | public | removed     |
+| `ModalUtil`, `modalUtilObject`, `IClickPosition`                                                                                                                                                  | public | removed     |
+| `handleCloseResult`, `getButtonCallableProp`, `isModalType`, `isTemplateRef`, `isNonEmptyString`, `isComponent`, `isModalButtons`, `onClickMask`, `onClickOkCancel`, `onButtonClick`, `onKeyDown` | public | `protected` |
+| `maskAnimationClassMap`, `modalAnimationClassMap`                                                                                                                                                 | public | `protected` |
+
+`transformOrigin` deserves a note. It was recomputed on every open from the last document click
+position, which starts at `{x: -1, y: -1}` and was never reset, and it was applied against keyframes
+that end at `transform: scale(1)` — against which `transform-origin` is a no-op. Nothing it produced
+was ever visible, and the document-wide click listener feeding it was registered at module load and
+never removed.
+
+## The behaviour changes
+
+**`(kbqOnOk)` / `(kbqOnCancel)` close the dialog now.** `handleCloseResult` branched on the runtime
+type of the trigger: an `EventEmitter` was emitted and the method returned. Both default to
+emitters, and only `KbqModalService.create()` replaced them with closures — so on a declarative
+`<kbq-modal [(kbqVisible)]>` the ×, the dim layer and the predefined OK/Cancel buttons emitted and
+did nothing at all. The emitter form is a notification now; the veto lives on the callable form,
+which keeps the dialog open by returning `false`.
+
+**<kbd>Escape</kbd> has one implementation.** It honours `kbqCloseByESC` on both paths — a
+declarative `[kbqCloseByESC]="false"` used to close anyway — and it routes through `kbqOnCancel`, so
+a callback returning `false` vetoes it, which it could not do on the service path either.
+
+**A service-created dialog is destroyed with its opener.** Its lifetime is bound to
+`options.injector`, or to the root environment injector when none is passed. Destroying the opener
+used to leave the dialog painted over the next view, with `afterClose` never emitting and the page
+scroll still locked.
+
+## What it does _not_ do
+
+Nothing is rewritten. A removed member has no replacement expression, and whether a dialog should
+still close where it used to stay open is a decision the schematic cannot make.
+
+| Pattern                                                         | Manual migration                                                                                  |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `(kbqOnOk)` / `(kbqOnCancel)`                                   | Nothing, unless you relied on the dialog staying open — then pass a function that returns `false` |
+| `.transformOrigin` / `.getKbqFooter()` / …                      | Delete the call; none of them produced anything a host could use                                  |
+| `.handleCloseResult()` / `.isTemplateRef()` / …                 | Protected; use `open()`/`close()`/`destroy()`, `triggerOk()`, `triggerCancel()`                   |
+| `ModalUtil` / `modalUtilObject`                                 | Delete the import                                                                                 |
+| `.kbq-modal-open` / `--kbq-modal-size-close-button-margin-left` | Delete the rule; neither had a reader                                                             |
+
+## Why the inputs are still decorators
+
+Every other component in this review series ended on `input()`/`model()`. `KbqModalComponent` did
+not, deliberately, and no consumer read needs an added `()`.
+
+`ModalBuilderForService.changeProps` applies the whole options object with
+`Object.assign(this.modalRef.instance, inputs)`. A signal input is a function held on the instance,
+so a bulk assignment overwrites the `InputSignal` itself rather than writing through it — the
+imperative path would have to be rewritten to a per-key `componentRef.setInput()`, with a runtime
+allow-list standing in for the type checking `Object.assign` currently gets for free.
+
+`kbqOnOk` and `kbqOnCancel` are the harder half: each is declared `@Input() @Output()` on one
+property, holding either an `EventEmitter` or a callback, and branched on at runtime. There is no
+signal shape for a member that is an input and an output at once, so splitting them is a second
+breaking change to an API this migration has already changed the semantics of. Doing both at once
+would leave consumers no working intermediate state.
+
+`kbqVisible` is the one member that would collapse cleanly into `model()` — it is an accessor pair
+with a matching `kbqVisibleChange` output — but it is written from `changeProps` like the rest, and
+`ngOnChanges` on it is what drives `handleVisibleStateChange`. It moves when the two above do.
+
+## Notes with no call site to point at
+
+- The dialog carries `role="dialog"`, `aria-modal="true"` and an accessible name — `kbqTitle`, or
+  the new `kbqAriaLabel` option when there is no title. A confirm or header-less dialog opened
+  without `kbqAriaLabel` is announced unnamed.
+- A manually composed dialog is named and described by its own `kbq-modal-title` and
+  `kbq-modal-caption`, on the same `aria-labelledby`/`aria-describedby` attributes the service path
+  uses, so the two entry paths announce alike.
+- `kbq-modal-title` projects a `[kbqModalTitleActions]` slot, rendered beside the heading and
+  outside its two-line clamp, for controls that belong next to the title rather than in the footer.
+- While a dialog is shown, every body child that does not contain an overlay is marked `inert`, and
+  so is every dialog below the topmost one. Code that reaches into the page behind an open dialog no
+  longer takes effect.
+- Initial focus follows the new `kbqAutoFocus` option (`'first-tabbable'` by default, plus
+  `'dialog'`, `'first-heading'` and `false`), with `[cdkFocusInitial]`/`autofocus` winning over it.
+- `kbqAfterOpen`/`kbqAfterClose` passed in the options are mirrored onto the dialog instead of
+  replacing its own emitters, and a declarative modal no longer emits `kbqBeforeClose`/`kbqAfterClose`
+  once on creation.
+- The dialog is a flex column capped at the viewport minus `--kbq-modal-size-viewport-inset`, so only
+  the body scrolls. A host that overrode the old `max-height: calc(100vh - 260px)` on
+  `.kbq-modal-body` can drop that override. One that used `kbqBodyStyle: { maxHeight: 'none' }` to let
+  the dialog outgrow the viewport has to move the override onto the dialog element —
+  `kbqStyle: { maxHeight: 'none' }` — because the cap lives there now; lifting it on the body only
+  makes the body scroll.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:modal-dialog-semantics --project my-app
+```

package/schematics/migrations/modal-dialog-semantics/data.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * Data for the `modal-dialog-semantics` migration.
+ *
+ * The modal review made the dialog a real dialog and closed the seam between its two entry paths:
+ *
+ * - `.kbq-modal-container` carries `role="dialog"`, `aria-modal`, `aria-labelledby`/`aria-label`
+ *   and the focus trap; the page behind an open dialog is marked `inert`.
+ * - The `EventEmitter` form of `kbqOnOk`/`kbqOnCancel` closes the dialog now, so `×`, the dim
+ *   layer and the predefined buttons work on a declarative `<kbq-modal [(kbqVisible)]>`.
+ * - <kbd>Escape</kbd> has one implementation for both paths: it honours `kbqCloseByESC` and runs
+ *   through `kbqOnCancel`, veto included.
+ * - A service-created dialog is destroyed with the injector that opened it.
+ * - `transformOrigin`, `getKbqFooter()`, `getContainerClasses()` and `autoFocusedButtons` are gone;
+ *   the template-only helpers became `protected`.
+ *
+ * Warn-only. A removed member has no replacement expression, and what a closing dialog should do
+ * instead is a decision the schematic cannot make.
+ */
+/** Import specifier that marks a file as a modal consumer. */
+const MODAL_PACKAGE = '@koobiq/components/modal';
+/** Identifier and attribute shapes that mark a consumer without an import. */
+const MODAL_TYPE = '\\bKbqModal\\w*\\b|\\bkbq-modal\\b';
+const warnPatterns = [
+    {
+        anchor: MODAL_TYPE,
+        pattern: '\\((?:kbqOnOk|kbqOnCancel)\\)',
+        message: 'A (kbqOnOk)/(kbqOnCancel) binding no longer keeps the dialog open. The EventEmitter form ' +
+            'used to emit and return, so on a declarative <kbq-modal [(kbqVisible)]> the ×, the dim ' +
+            'layer and the predefined buttons emitted and did nothing; it is a notification now and ' +
+            'the dialog closes. To keep a close under your control, pass kbqOnOk/kbqOnCancel as a ' +
+            'function and return false from it.'
+    },
+    {
+        anchor: MODAL_TYPE,
+        pattern: '\\.\\s*(?:transformOrigin|getKbqFooter|getContainerClasses|autoFocusedButtons)\\b',
+        message: 'KbqModalComponent.transformOrigin / getKbqFooter() / getContainerClasses() / ' +
+            'autoFocusedButtons were removed. transformOrigin was computed from a click position ' +
+            'set to {x: -1, y: -1} and applied against keyframes that end at scale(1), so it ' +
+            'never rendered anything; autoFocusedButtons queried a template reference that does not ' +
+            'exist. The class list is an internal field the template reads directly.'
+    },
+    {
+        anchor: MODAL_TYPE,
+        pattern: '\\.\\s*(?:handleCloseResult|getButtonCallableProp|isModalType|isTemplateRef|isNonEmptyString|' +
+            'isComponent|isModalButtons|onClickMask|onClickOkCancel|onButtonClick|onKeyDown|' +
+            'maskAnimationClassMap|modalAnimationClassMap)\\b',
+        message: 'The KbqModalComponent members that only ever fed its own template are protected now: ' +
+            'handleCloseResult, getButtonCallableProp, isModalType, isTemplateRef, isNonEmptyString, ' +
+            'isComponent, isModalButtons, onClickMask, onClickOkCancel, onButtonClick, onKeyDown and the ' +
+            'two animation class maps. The supported surface is open()/close()/destroy(), triggerOk(), ' +
+            'triggerCancel() and the inputs.'
+    },
+    {
+        anchor: MODAL_TYPE,
+        pattern: '\\bmodalUtilObject\\b|\\bModalUtil\\b|\\bIClickPosition\\b',
+        message: 'ModalUtil, modalUtilObject and IClickPosition were removed together with the ' +
+            'transform-origin machinery they fed, including the document-wide click listener they ' +
+            'registered at module load and never removed.'
+    },
+    {
+        anchor: MODAL_TYPE,
+        pattern: '\\bkbq-modal-open\\b|--kbq-modal-size-close-button-margin-left',
+        message: 'The .kbq-modal-open class and the --kbq-modal-size-close-button-margin-left token were ' +
+            'removed: neither had a single reader. The body scroll lock is an inline style, and the ' +
+            'close button is positioned absolutely. The dialog now reads a new ' +
+            '--kbq-modal-size-viewport-inset token (48px) for the gap it keeps to each viewport edge.'
+    }
+];
+/** Printed once per project, after the per-file reports. */
+const SUMMARY = [
+    '  The dialog element carries role="dialog", aria-modal="true" and an accessible name — the ' +
+        'kbqTitle by default, the new kbqAriaLabel option when there is none. A confirm or ' +
+        'header-less dialog opened without kbqAriaLabel is announced unnamed. Hand-rolled role or ' +
+        'aria-* attributes on the dialog are duplicates now.',
+    '  While a dialog is shown, every body child that does not contain an overlay is marked inert, ' +
+        'and every dialog below the topmost one is too. Code that reaches into the page behind an ' +
+        'open dialog — a click, a focus() — no longer takes effect.',
+    '  Initial focus follows kbqAutoFocus (first-tabbable by default, plus dialog, first-heading and ' +
+        'false), with [cdkFocusInitial]/autofocus winning over it. A dialog with no focusable ' +
+        'control focuses itself instead of leaving focus on the trigger behind it.',
+    '  Escape honours kbqCloseByESC on both entry paths and runs through kbqOnCancel, so a callback ' +
+        'returning false vetoes it. It used to close a declarative dialog unconditionally and to ' +
+        'ignore the veto on the service path.',
+    '  A dialog opened through KbqModalService is destroyed with the injector that opened it — ' +
+        'options.injector, or the root environment injector. Destroying the opener used to leave the ' +
+        'dialog painted over the next view with the page scroll still locked.',
+    '  The kbqAfterOpen/kbqAfterClose options are mirrored onto the dialog instead of replacing its ' +
+        'own emitters, so afterOpen/afterClose on the returned ref keep emitting; and a declarative ' +
+        'modal no longer emits kbqBeforeClose/kbqAfterClose once on creation.',
+    '  The dialog is a flex column capped at the viewport minus its inset, so only the body scrolls ' +
+        'and the header and the footer stay on screen. A modal that overrode the old ' +
+        'max-height: calc(100vh - 260px) on .kbq-modal-body can drop that override; one that used ' +
+        'kbqBodyStyle: { maxHeight: none } to let the dialog outgrow the viewport has to move that ' +
+        'override onto the dialog element, kbqStyle: { maxHeight: none }, because the cap lives there now.',
+    '  A manually composed dialog is named and described by its own kbq-modal-title and ' +
+        'kbq-modal-caption, on the same aria-labelledby/aria-describedby the service path uses, so ' +
+        'both entry paths are announced alike. kbq-modal-title also projects a [kbqModalTitleActions] ' +
+        'slot, rendered beside the heading and outside its two-line clamp.',
+    '  The inputs of KbqModalComponent are still decorators: KbqModalService applies its options ' +
+        'with Object.assign, which would overwrite an InputSignal rather than write through it, and ' +
+        'kbqOnOk/kbqOnCancel are @Input() and @Output() on one property. No consumer read needs an ' +
+        'added ().'
+];
+
+exports.MODAL_PACKAGE = MODAL_PACKAGE;
+exports.MODAL_TYPE = MODAL_TYPE;
+exports.SUMMARY = SUMMARY;
+exports.warnPatterns = warnPatterns;

package/schematics/migrations/modal-dialog-semantics/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var migrations_modalDialogSemantics_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const LABEL = '[modal-dialog-semantics]';
+const EXTENSIONS = ['.ts', '.html', '.scss'];
+/** A file is a modal consumer if it imports the package, names the component, or renders one. */
+function referencesModal(content) {
+    return content.includes(migrations_modalDialogSemantics_data.MODAL_PACKAGE) || new RegExp(migrations_modalDialogSemantics_data.MODAL_TYPE).test(content);
+}
+/**
+ * Reports what the modal review changed for consumers: the members that disappeared or became
+ * protected, and the close controls that stopped being inert on the declarative path. Never
+ * writes — whether a dialog should still close is a decision, not a rewrite.
+ *
+ * `.html` is visited because `(kbqOnOk)`/`(kbqOnCancel)` are template bindings, and `.scss` because
+ * two of the removals are a class and a design token.
+ */
+function modalDialogSemantics(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root) : tree.root;
+        let consumers = 0;
+        let reported = 0;
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath, entry) => {
+            if (!EXTENSIONS.some((extension) => filePath.endsWith(extension)))
+                return;
+            const content = entry?.content.toString();
+            if (!content || !referencesModal(content))
+                return;
+            consumers++;
+            for (const { anchor, pattern, message } of migrations_modalDialogSemantics_data.warnPatterns) {
+                if (!new RegExp(anchor).test(content) || !new RegExp(pattern).test(content))
+                    continue;
+                reported++;
+                utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+            }
+        });
+        // Nothing here opens a modal, so the summary would only be noise.
+        if (consumers === 0)
+            return;
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed kbq-modal under "${root || '<workspace root>'}", ` +
+                `${consumers} file(s) reference the component, ${reported} call site(s) reported.`,
+            ...migrations_modalDialogSemantics_data.SUMMARY
+        ]);
+    };
+}
+
+exports.default = modalDialogSemantics;

package/schematics/migrations/modal-dialog-semantics/schema.json

@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-modal-dialog-semantics",
+    "title": "Koobiq components modal review migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to inspect. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}

package/schematics/migrations/modal-signals/README.md

@@ -0,0 +1,88 @@
+# modal-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21`
+(registered for `21.0.0-0`). Rewrites reads of the `KbqModalComponent` members that became signals
+into calls, and reports the two renames and the reads it cannot resolve.
+
+Runs alongside [`modal-dialog-semantics`](../modal-dialog-semantics/README.md), which covers the
+behaviour and visibility changes of the same review. This one covers only the move to signals.
+
+## Background
+
+Two things kept the dialog on decorator inputs while the rest of the review series moved to
+`input()`.
+
+`ModalBuilderForService` applied the whole options object with
+`Object.assign(this.modalRef.instance, inputs)`. A bulk assignment overwrites an `InputSignal`
+instead of writing through it, so every option would have broken at once. The options are provided
+as `KBQ_MODAL_OPTIONS` now, and the dialog reads them as the **initial values** of its inputs: a
+dialog created by the service carries no template bindings, so an input it does not bind keeps that
+initial value for life. That also removed the four `if (!('x' in options))` blocks in
+`KbqModalService.create()`, which only existed to make `Object.assign` overwrite a default.
+
+`kbqOnOk` and `kbqOnCancel` were each `@Input()` **and** `@Output()` on one property. A signal input
+and an output cannot share a name, so the pair had to be split first — see
+[`modal-dialog-semantics`](../modal-dialog-semantics/README.md) for that half.
+
+## What it rewrites
+
+A read of a migrated member becomes a call, on receivers the engine can resolve: a variable or
+field annotated `KbqModalComponent`, an `inject()`/`viewChild()`/`contentChild()` of it, and a
+`#ref` on a `<kbq-modal>` element in an external or inline template. A write to `kbqVisible` becomes
+`kbqVisible.set(...)`, because it is the one `model()`.
+
+| Call site                      | Becomes                                             |
+| ------------------------------ | --------------------------------------------------- |
+| `modal.kbqVisible`             | `modal.kbqVisible()`                                |
+| `modal.kbqVisible = true`      | `modal.kbqVisible.set(true)`                        |
+| `modal.kbqTitle`, `kbqSize`, … | `modal.kbqTitle()`, `modal.kbqSize()`, …            |
+| `modal.kbqTitle = 'x'`         | Reported — bind `[kbqTitle]`; the input is readonly |
+
+## What it reports instead
+
+- **`kbqOnOk:` / `kbqOnCancel:` as a key.** The decision handler is `kbqOkClick`/`kbqCancelClick`
+  now, but `kbqOnOk` survives as an output under the same name, so the key has to be judged in
+  context: an options object and an `[kbqOnOk]` input binding move, a `(kbqOnOk)` listener does not.
+  `ModalOptions.kbqOnOk` is an `EventEmitter` now, so a function left under the old key is a compile
+  error rather than a silent change of meaning.
+- **`[kbqOnOk]` / `[kbqOnCancel]` input bindings.** The old names are outputs only, so Angular would
+  drop the binding silently.
+- **Reads through `KbqModalRef.getInstance()`.** The ref is what `KbqModalService` returns and its
+  static type carries none of these members, so the engine has nothing to resolve the receiver to.
+- **`okText` / `cancelText`.** Removed. They were getters returning `kbqOkText`/`kbqCancelText`
+  unchanged and existed only to feed the template.
+- **The four template type guards** — `isTemplateRef`, `isNonEmptyString`, `isComponent`,
+  `isModalButtons`. Removed; the template classifies each slot once instead. They were already
+  `protected` and `@docs-private`, so only a subclass is affected.
+
+## Notes with no call site to point at
+
+- `kbqOkLoading`, `kbqCancelLoading` and `kbqMask` keep a private writable shadow inside the dialog,
+  because something other than the binding drives them: a pending promise returned by a handler, and
+  a dialog that covers this one. The inputs keep reporting what was bound, so re-binding one still
+  takes effect.
+- The predefined OK and Cancel buttons finally render the progress state `kbqOkLoading` and
+  `kbqCancelLoading` always described. The template never read them before, so a promise-returning
+  handler showed nothing.
+- `kbqFooter` is no longer overwritten with its own formatted copy on init, so it reports exactly
+  what was bound; the button defaults are filled in on the way to the template.
+- `KbqModalComponent` no longer declares `implements ModalOptions`. That interface is the service's
+  contract, and the component's inputs are signals, so the two no longer match structurally.
+- `KbqModalControlService` still turns the dim layer of covered dialogs off and back on from
+  outside, through `animateMaskTo()` and the new `setMaskEnabled()`. That orchestration belongs in
+  the dialog, keyed on `topVisibleModal()` the way `inert` already is, and has not moved yet.
+- `kbqAfterOpen`, `kbqAfterClose` and `kbqBeforeClose` are still `@Output() EventEmitter`. They back
+  the public `afterOpen`/`beforeClose`/`afterClose` observables, and `output()` is not a drop-in:
+  `OutputEmitterRef` has no `asObservable()`, and `outputToObservable()` completes the stream when
+  the component is destroyed — which happens inside the emit itself, because
+  `ModalBuilderForService` subscribes first to dispose the overlay, so the value is dropped before
+  it reaches a consumer's `afterClose`. Converting them means moving the source of truth to a
+  `Subject` the dialog owns and taking the overlay teardown off that emitter.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:modal-signals --project my-app
+```
+
+Pass `--fix=false` to see what would change without writing.

package/schematics/migrations/modal-signals/data.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+ * Data for the `modal-signals` migration.
+ *
+ * `KbqModalComponent` finished its move to signals:
+ *
+ * - every option is an `input()` now, `kbqVisible` is a `model()`, and the hand-written
+ *   `kbqVisibleChange` output is the one the model generates;
+ * - `kbqOnOk`/`kbqOnCancel` are an output each, and the decision handler they used to double as
+ *   is a separate input: `kbqOkClick`/`kbqCancelClick`;
+ * - `KbqModalService` stopped applying the options with `Object.assign` — they reach the dialog
+ *   through `KBQ_MODAL_OPTIONS` as the initial values of its inputs;
+ * - the `okText`/`cancelText` getters and the four template type guards are gone.
+ *
+ * Reads are rewritten to calls by the shared engine. The two renames are reported rather than
+ * rewritten: `kbqOnOk` survives as an output under the same name, so the key has to be judged in
+ * context — an option object and an `[kbqOnOk]` input binding move, a `(kbqOnOk)` listener does not.
+ */
+/** Import specifier that marks a file as a modal consumer. */
+const MODAL_PACKAGE = '@koobiq/components/modal';
+/** Identifier and attribute shapes that mark a consumer without an import. */
+const MODAL_TYPE = '\\bKbqModal\\w*\\b|\\bkbq-modal\\b';
+/** Every input that became a signal. `kbqVisible` is the `model()`; the rest are read-only. */
+const MODAL_MEMBERS = [
+    'kbqModalType',
+    'kbqComponent',
+    'kbqContent',
+    'kbqFooter',
+    'kbqVisible',
+    'kbqWidth',
+    'kbqSize',
+    'kbqWrapClassName',
+    'kbqClassName',
+    'kbqStyle',
+    'kbqTitle',
+    'kbqCaption',
+    'kbqCloseByESC',
+    'kbqAutoFocus',
+    'kbqAriaLabel',
+    'kbqClosable',
+    'kbqMask',
+    'kbqMaskClosable',
+    'kbqMaskStyle',
+    'kbqBodyStyle',
+    'kbqOkText',
+    'kbqOkType',
+    'kbqRestoreFocus',
+    'kbqOkLoading',
+    'kbqOkClick',
+    'kbqCancelText',
+    'kbqCancelLoading',
+    'kbqCancelClick',
+    'kbqGetContainer'
+];
+const config = {
+    label: '[modal-signals]',
+    package: MODAL_PACKAGE,
+    membersByType: { KbqModalComponent: MODAL_MEMBERS },
+    // The dialog is a component with no `exportAs`, so a template names it by its own element.
+    exportAsToType: {},
+    elementToType: { 'kbq-modal': 'KbqModalComponent' },
+    writableMembers: new Set(['kbqVisible']),
+    warnPatterns: [
+        {
+            anchor: MODAL_TYPE,
+            pattern: '\\bkbqOnOk\\s*:|\\bkbqOnCancel\\s*:',
+            message: 'The decision handler moved off kbqOnOk/kbqOnCancel. In an options object or an ' +
+                '[kbqOnOk] input binding, rename the key to kbqOkClick/kbqCancelClick: ' +
+                'modalService.create({ kbqOnOk: fn }) becomes create({ kbqOkClick: fn }). kbqOnOk and ' +
+                'kbqOnCancel survive as outputs under the same names, so a (kbqOnOk) listener in a ' +
+                'template is unaffected — and ModalOptions.kbqOnOk is an EventEmitter now, so a ' +
+                'function left under the old key is a compile error rather than a silent change.'
+        },
+        {
+            anchor: MODAL_TYPE,
+            pattern: '\\[\\s*(?:kbqOnOk|kbqOnCancel)\\s*\\]',
+            message: 'An [kbqOnOk]/[kbqOnCancel] input binding is now [kbqOkClick]/[kbqCancelClick]. The old ' +
+                'names are outputs only, so the binding would be dropped silently.'
+        },
+        {
+            anchor: MODAL_TYPE,
+            pattern: '\\.\\s*getInstance\\(\\)\\s*\\.\\s*kbq[A-Z]',
+            message: 'Reads through KbqModalRef.getInstance() are not rewritten, because the ref is what ' +
+                'KbqModalService returns and its static type carries none of these members. Every input ' +
+                'read behind getInstance() needs a call now — getInstance().kbqVisible() — and a write ' +
+                'needs a binding, except kbqVisible, which is a model(): getInstance().kbqVisible.set(v), ' +
+                'or just open()/close().'
+        },
+        {
+            anchor: MODAL_TYPE,
+            pattern: '\\.\\s*(?:okText|cancelText)\\b',
+            message: 'KbqModalComponent.okText / cancelText were removed. They were getters that returned ' +
+                'kbqOkText / kbqCancelText unchanged and existed only to feed the template; read the ' +
+                'inputs instead — kbqOkText().'
+        },
+        {
+            anchor: MODAL_TYPE,
+            pattern: '\\.\\s*(?:isTemplateRef|isNonEmptyString|isComponent|isModalButtons)\\b',
+            message: 'The four template type guards of KbqModalComponent were removed — isTemplateRef, ' +
+                'isNonEmptyString, isComponent and isModalButtons. The template classifies each slot ' +
+                'once instead. They were already protected and @docs-private, so only a subclass is ' +
+                'affected.'
+        }
+    ],
+    messages: {
+        unparseableTemplate: 'This template renders a kbq-modal but could not be parsed, so reads through a template ' +
+            'reference variable were left alone. Check them by hand.',
+        unresolvedReceiver: 'KbqModalComponent is named here, but these reads could not be tied to one receiver, so ' +
+            'they were left alone:',
+        summary: [
+            '  Every option of KbqModalComponent is a signal input now, and kbqVisible is a model(). ' +
+                'Template bindings are unchanged, including [(kbqVisible)]; what breaks is programmatic ' +
+                'access — a read takes a call and a write takes a binding.',
+            '  KbqModalService no longer applies the options with Object.assign. They are provided as ' +
+                'KBQ_MODAL_OPTIONS and become the initial values of the inputs, so a dialog created by ' +
+                'the service keeps them for life.',
+            '  kbqOkLoading, kbqCancelLoading and kbqMask keep a private writable shadow inside the ' +
+                'dialog, because a pending promise and a covering dialog drive them. The inputs keep ' +
+                'reporting what was bound, so re-binding one still takes effect.',
+            '  kbqFooter is no longer overwritten with its own formatted copy on init, and the ' +
+                'predefined OK/Cancel buttons finally render the progress state kbqOkLoading and ' +
+                'kbqCancelLoading always described.',
+            '  KbqModalComponent no longer declares `implements ModalOptions`: that interface is the ' +
+                "service's contract, and the component's inputs are signals, so the two no longer match."
+        ]
+    }
+};
+
+exports.MODAL_PACKAGE = MODAL_PACKAGE;
+exports.MODAL_TYPE = MODAL_TYPE;
+exports.config = config;

package/schematics/migrations/modal-signals/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var signalMembersMigration = require('../../signal-members-migration-BoAJKutT.js');
+var migrations_modalSignals_data = require('./data.js');
+require('typescript');
+require('../../utils/ast.js');
+require('../../utils/messages.js');
+require('../../package-config-BhU2TfC8.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+require('../../utils/typescript.js');
+
+function modalSignals(options) {
+    return signalMembersMigration.signalMembersRule(migrations_modalSignals_data.config, options);
+}
+
+exports.default = modalSignals;

package/schematics/migrations/modal-signals/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-modal-signals",
+    "title": "Koobiq components modal signals migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to migrate. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        },
+        "fix": {
+            "type": "boolean",
+            "default": true,
+            "description": "When true, applies all auto-fix replacements. When false, prints what would change without writing."
+        }
+    }
+}