@koobiq/components 20.4.1 → 21.0.0

package/schematics/migrations/locale-configuration-providers/index.js

@@ -0,0 +1,294 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+var migrations_localeConfigurationProviders_data = require('./data.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+const LABEL = '[locale-configuration-providers]';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const createSourceFile = (fileName, content) => ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+/** The name of a `{ key: value }` property, covering both `provide:` and `'provide':`. */
+function assignedPropertyName(property) {
+    if (!ts.isPropertyAssignment(property))
+        return null;
+    if (!ts.isIdentifier(property.name) && !ts.isStringLiteralLike(property.name))
+        return null;
+    return property.name.text;
+}
+function findProperty(literal, name) {
+    return literal.properties.find((property) => assignedPropertyName(property) === name);
+}
+/** The migrated token a `{ provide: … }` object literal names, if it names one at all. */
+function providedToken(node) {
+    if (!ts.isObjectLiteralExpression(node))
+        return null;
+    const initializer = findProperty(node, migrations_localeConfigurationProviders_data.PROVIDE_PROPERTY)?.initializer;
+    if (!initializer || !ts.isIdentifier(initializer))
+        return null;
+    return migrations_localeConfigurationProviders_data.MIGRATED_PROVIDER_TOKENS.find(({ token }) => token === initializer.text) ?? null;
+}
+/**
+ * Collects the `{ provide: KBQ_<X>_CONFIGURATION, useValue: … }` entries to rewrite, and the
+ * provider objects that need a human instead.
+ */
+function scanProviders(sourceFile) {
+    const rewrites = [];
+    const warnings = [];
+    const visit = (node) => {
+        const entry = providedToken(node);
+        if (entry) {
+            const literal = node;
+            const unsupported = migrations_localeConfigurationProviders_data.UNSUPPORTED_PROPERTIES.find((name) => findProperty(literal, name));
+            const value = findProperty(literal, migrations_localeConfigurationProviders_data.VALUE_PROPERTY);
+            if (unsupported) {
+                warnings.push({ token: entry.token, message: migrations_localeConfigurationProviders_data.unsupportedShapeMessage(entry, unsupported) });
+            }
+            else if (!ts.isArrayLiteralExpression(literal.parent)) {
+                // Being an array element is what makes the entry safe to replace. A provider object bound
+                // to a name (`export const P = { provide: KBQ_…, useValue: … };`) is not an element of
+                // anything, and the helper returns a `Provider` rather than an object literal — swapping it
+                // in would silently change what that name means to everything that reads it.
+                warnings.push({ token: entry.token, message: migrations_localeConfigurationProviders_data.nonArrayProviderMessage(entry) });
+            }
+            else if (value && literal.properties.every((property) => isKnownProperty(property))) {
+                rewrites.push({
+                    start: literal.getStart(sourceFile),
+                    end: literal.getEnd(),
+                    text: `${entry.helper}(${sourceFile.text.slice(value.initializer.getStart(sourceFile), value.initializer.getEnd())})`,
+                    entry
+                });
+            }
+            // Anything left — no `useValue` at all, a spread, or an extra property such as `multi` that
+            // the single-argument helper has nowhere to put — keeps the token, so the leftover-reference
+            // warning reports it.
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return { rewrites, warnings };
+}
+function isKnownProperty(property) {
+    const name = assignedPropertyName(property);
+    return name === migrations_localeConfigurationProviders_data.PROVIDE_PROPERTY || name === migrations_localeConfigurationProviders_data.VALUE_PROPERTY;
+}
+/** Splices the replacements in right-to-left, so earlier offsets stay valid. */
+function applyRewrites(content, rewrites) {
+    let result = content;
+    for (const { start, end, text } of [...rewrites].sort((a, b) => b.start - a.start)) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return result;
+}
+/**
+ * Whether `name` is still used outside an import statement. The import clause itself does not count —
+ * it is exactly what gets dropped once nothing else refers to the token.
+ */
+function hasNonImportReference(sourceFile, name) {
+    let found = false;
+    const visit = (node) => {
+        if (found || ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && node.text === name) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return found;
+}
+/**
+ * Idempotently strips `symbol` from any `import { … } from 'from'` clause.
+ * - Multi-symbol clause: drop just that symbol, keep the others.
+ * - Single-symbol clause: drop the whole import line.
+ */
+function removeImport(content, symbol, from) {
+    // The trailing part deliberately stops after a single newline (`[ \t]*\r?\n?` rather than `\s*\n?`):
+    // dropping the whole import line must not also swallow the blank line that separates the import
+    // block from the code below it.
+    const moduleRe = new RegExp(`(import\\s*(?:type\\s*)?\\{)([^}]*)(\\}\\s*from\\s*['"]${escapeRegExp(from)}['"];?[ \\t]*\\r?\\n?)`, 'g');
+    return content.replace(moduleRe, (full, open, body, close) => {
+        const items = body
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+        // An already-empty clause is somebody else's import — leave it alone.
+        if (items.length === 0)
+            return full;
+        // Handle `<name> as <alias>` — match on the source name, not the alias.
+        const kept = items.filter((spec) => spec.split(/\s+as\s+/)[0].trim() !== symbol);
+        if (kept.length === items.length)
+            return full;
+        if (kept.length === 0)
+            return '';
+        return `${open} ${kept.join(', ')} ${close}`;
+    });
+}
+/**
+ * Idempotently adds `import { symbol } from 'from'`: into an existing clause of the same module when
+ * there is one, otherwise as a new line after the leading comments.
+ */
+function ensureImport(content, symbol, from) {
+    // Already imported from anywhere — a re-export or an alias — so leave it alone.
+    const alreadyImported = new RegExp(`import\\s*(?:type\\s*)?\\{[^}]*\\b${escapeRegExp(symbol)}\\b[^}]*\\}\\s*from\\s*['"][^'"]+['"]`);
+    if (alreadyImported.test(content))
+        return content;
+    // Deliberately matches a value clause only: a file may carry a separate `import type { … }` clause for
+    // the same module, and splicing a helper that is called as a value into that one is a compile error.
+    const sameModule = new RegExp(`(import\\s*\\{)([^}]*)(\\}\\s*from\\s*['"]${escapeRegExp(from)}['"])`);
+    if (sameModule.test(content)) {
+        return content.replace(sameModule, (_full, open, body, close) => {
+            const trimmed = body.trim().replace(/,$/, '');
+            const next = trimmed.length === 0 ? ` ${symbol} ` : `${body.replace(/\s*$/, '')}, ${symbol} `;
+            return `${open}${next}${close}`;
+        });
+    }
+    const lines = content.split('\n');
+    let insertAt = 0;
+    let inBlockComment = false;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (inBlockComment) {
+            if (trimmed.endsWith('*/'))
+                inBlockComment = false;
+            insertAt = i + 1;
+            continue;
+        }
+        if (trimmed.startsWith('/*')) {
+            inBlockComment = !trimmed.includes('*/');
+            insertAt = i + 1;
+            continue;
+        }
+        if (trimmed.startsWith('//') || trimmed.length === 0) {
+            insertAt = i + 1;
+            continue;
+        }
+        break;
+    }
+    lines.splice(insertAt, 0, `import { ${symbol} } from '${from}';`);
+    return lines.join('\n');
+}
+/** The migrated tokens the rewrite pass touched, in declaration order. */
+function rewrittenTokens(rewrites) {
+    return migrations_localeConfigurationProviders_data.MIGRATED_PROVIDER_TOKENS.filter((entry) => rewrites.some(({ entry: touched }) => touched === entry));
+}
+/** Compiled once: the table is fixed, and the pass runs over every file of the project. */
+const compiledRenames = migrations_localeConfigurationProviders_data.RENAMED_SYMBOLS.map(({ from, to }) => ({ pattern: new RegExp(`\\b${from}\\b`, 'g'), to }));
+/**
+ * Renames the locale symbols that moved onto their section's name. A word-boundary rewrite is enough
+ * here: no old name is a prefix of another one at a word boundary, and none of them is a common word.
+ */
+function renameSymbols(content) {
+    return compiledRenames.reduce((result, { pattern, to }) => result.replace(pattern, to), content);
+}
+function logWarnings(context, filePath, content, patterns) {
+    const mentionsComponent = migrations_localeConfigurationProviders_data.COMPONENT_MENTIONS.some((mention) => content.includes(mention));
+    for (const { pattern, message, needsComponentMention } of patterns) {
+        if (needsComponentMention && !mentionsComponent)
+            continue;
+        if (new RegExp(pattern).test(content)) {
+            utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+        }
+    }
+}
+/**
+ * Reports the tokens still referenced after the rewrite pass — an `inject()` call, a provider shape the
+ * helper could not take over, a re-export. `alreadyWarned` holds the tokens a more specific message
+ * already covered, so a single provider is never reported twice.
+ */
+function logLeftoverTokens(context, filePath, content, alreadyWarned) {
+    const candidates = migrations_localeConfigurationProviders_data.MIGRATED_PROVIDER_TOKENS.filter(({ token }) => !alreadyWarned.has(token) && content.includes(token));
+    if (candidates.length === 0)
+        return;
+    const sourceFile = createSourceFile(filePath, content);
+    for (const entry of candidates) {
+        if (!hasNonImportReference(sourceFile, entry.token))
+            continue;
+        utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${migrations_localeConfigurationProviders_data.leftoverTokenMessage(entry)}`]);
+    }
+}
+function localeConfigurationProviders(options) {
+    return async (tree, context) => {
+        const { project } = options;
+        // `ng update` invokes migrations with no options at all, and migrations.json declares no schema,
+        // so the schema default never reaches us — applying the fix is the intended behaviour there.
+        const fix = options.fix ?? true;
+        const projectDefinition = await utils_packageConfig.setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root) : tree.root;
+        const filePaths = [];
+        utils_packageConfig.visitProjectFiles(rootDir, (filePath) => {
+            if (!filePath.endsWith(TS_EXT) && !filePath.endsWith(HTML_EXT))
+                return;
+            filePaths.push(filePath);
+        });
+        let touched = 0;
+        for (const filePath of filePaths) {
+            const originalContent = tree.read(filePath)?.toString();
+            if (!originalContent)
+                continue;
+            // Renames run first: every later pass — the provider rewrite, the leftover check, the member
+            // warnings — is written against the names the section has now, and a project arriving here
+            // still carries the released ones.
+            let content = renameSymbols(originalContent);
+            const providerWarnings = [];
+            const isTs = filePath.endsWith(TS_EXT);
+            // Parsing every `.ts` of the project is not free, and nothing can change in a file that
+            // mentions none of the tokens.
+            if (isTs && migrations_localeConfigurationProviders_data.MIGRATED_PROVIDER_TOKENS.some(({ token }) => content.includes(token))) {
+                const { rewrites, warnings } = scanProviders(createSourceFile(filePath, content));
+                providerWarnings.push(...warnings);
+                content = applyRewrites(content, rewrites);
+                if (content !== originalContent) {
+                    // Those edits moved every offset that followed them, and the leftover check has to see
+                    // the rewritten file rather than the positions it started with.
+                    const rewritten = createSourceFile(filePath, content);
+                    for (const entry of rewrittenTokens(rewrites)) {
+                        // The helper joins an existing clause of the module before the token leaves it, so
+                        // the import keeps its place in the file even when the token was its only symbol.
+                        content = ensureImport(content, entry.helper, entry.from);
+                        if (!hasNonImportReference(rewritten, entry.token)) {
+                            content = removeImport(content, entry.token, entry.from);
+                        }
+                    }
+                }
+            }
+            // Warn on what is left over, so an auto-fixed usage does not also produce a "manual migration
+            // required" note. In dry-run mode the fix is not written, so report against the original.
+            const reported = fix ? content : originalContent;
+            logWarnings(context, filePath, reported, migrations_localeConfigurationProviders_data.memberWarnPatterns);
+            if (isTs) {
+                for (const { message } of providerWarnings) {
+                    utils_messages.logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+                }
+                logLeftoverTokens(context, filePath, reported, new Set(providerWarnings.map(({ token }) => token)));
+            }
+            if (content === originalContent)
+                continue;
+            touched++;
+            if (fix) {
+                tree.overwrite(filePath, content);
+            }
+            else {
+                utils_messages.logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        }
+        utils_messages.logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            '',
+            ...migrations_localeConfigurationProviders_data.BEHAVIOUR_NOTE
+        ]);
+    };
+}
+
+exports.default = localeConfigurationProviders;

package/schematics/migrations/locale-configuration-providers/schema.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-locale-configuration-providers",
+    "title": "Koobiq components locale configuration providers",
+    "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."
+        }
+    }
+}

package/schematics/migrations/mandatory-peer-dependencies/README.md

@@ -0,0 +1,70 @@
+### Mandatory Peer Dependencies schematics
+
+This schematic adds the packages that became mandatory `peerDependencies` of `@koobiq/components`. It includes:
+
+- `overlayscrollbars`
+- `@koobiq/date-adapter`
+
+npm installs a newly mandatory peer on upgrade by itself, but Yarn does not and pnpm only does with
+`auto-install-peers`. Those projects would otherwise upgrade into a build that fails with
+`Cannot find module 'overlayscrollbars'`, since `ng add` is the only other place that writes these packages and
+`ng update` never runs it.
+
+An entry the project already declares is left untouched, so a `@koobiq/date-adapter` pinned below `3.4.0` keeps
+its version. That one is not an install error but a `TypeError: this.dateAdapter.addCalendarUnits is not a
+function` inside `kbq-time-range`, so the schematic warns about it instead. The warning is only printed for a
+project that brought its own range — one that had no entry at all just received the current one.
+
+[Params](schema.ts)
+
+Usage for Angular Cli:
+
+```shell
+ng g @koobiq/components:mandatory-peer-dependencies --project "<your project>"
+```
+
+Usage for Nx:
+
+```shell
+nx g @koobiq/components:mandatory-peer-dependencies --project "<your project>"
+```
+
+### Run locally
+
+Build package
+
+```shell
+yarn run build:schematics
+```
+
+Run command (for example, for `koobiq-docs` project)
+
+```shell
+ng g ./dist/components/schematics/collection.json:mandatory-peer-dependencies --project koobiq-docs
+```
+
+### Result
+
+#### Before
+
+```json
+{
+    "dependencies": {
+        "@angular/core": "^20.3.0",
+        "@koobiq/components": "^21.0.0"
+    }
+}
+```
+
+#### After
+
+```json
+{
+    "dependencies": {
+        "@angular/core": "^20.3.0",
+        "@koobiq/components": "^21.0.0",
+        "@koobiq/date-adapter": "^3.5.1",
+        "overlayscrollbars": "2.7.3"
+    }
+}
+```

package/schematics/migrations/mandatory-peer-dependencies/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tasks = require('@angular-devkit/schematics/tasks');
+var utils_messages = require('../../utils/messages.js');
+var utils_packageConfig = require('../../package-config-BhU2TfC8.js');
+require('@angular-devkit/schematics');
+require('@schematics/angular/utility');
+
+/**
+ * `@koobiq/components` now declares `overlayscrollbars` and `@koobiq/date-adapter` as mandatory peers.
+ *
+ * npm installs a newly mandatory peer on upgrade by itself, but Yarn does not and pnpm only does
+ * with `auto-install-peers`, so without this migration those consumers upgrade into a build that
+ * fails with "Cannot find module 'overlayscrollbars'". `ng add` is the only other place that writes
+ * these packages, and `ng update` never runs it.
+ */
+function migrate() {
+    return (tree, context) => {
+        // Read before the entry is added: `addPackageToPackageJson` leaves one that is already
+        // there untouched, so this is the last moment the project's own range is still visible.
+        const dateAdapterRange = utils_packageConfig.getPackageVersionFromPackageJson(tree, '@koobiq/date-adapter');
+        utils_packageConfig.addPackageToPackageJson(tree, 'overlayscrollbars', "2.7.3");
+        utils_packageConfig.addPackageToPackageJson(tree, '@koobiq/date-adapter', "^3.5.1");
+        context.addTask(new tasks.NodePackageInstallTask());
+        // Only when the project brought its own range, which the call above kept: one pinned below
+        // the new floor is not an install error but a
+        // `TypeError: this.dateAdapter.addCalendarUnits is not a function` inside `kbq-time-range`.
+        // A project that had no entry just got the current range and has nothing to act on.
+        if (dateAdapterRange) {
+            utils_messages.logMessage(context.logger, [
+                `\`@koobiq/date-adapter\` is declared as "${dateAdapterRange}" and was left untouched.`,
+                'It has to be 3.4.0 or newer — upgrade it together with the adapter you use',
+                '(`@koobiq/luxon-date-adapter` or `@koobiq/moment-date-adapter`): the date components',
+                'call `addCalendarUnits()` and `startOf()`, which 3.4.0 was the first to add.'
+            ]);
+        }
+    };
+}
+
+exports.default = migrate;

package/schematics/migrations/mandatory-peer-dependencies/schema.json

@@ -0,0 +1,15 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-mandatory-peer-dependencies",
+    "title": "koobiq-components mandatory-peer-dependencies schematic",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project",
+            "$default": {
+                "$source": "projectName"
+            }
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+# markdown-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21` (registered for
+`21.0.0-0`). Migrates `KbqMarkdown` consumers to its signal-based API and reports the two behavior
+fixes the review made.
+
+## Background
+
+`markdownText` was the component's only input, and its setter did the rendering — which is why the
+automated signal migration skipped it:
+
+```ts
+set markdownText(value: string | null) {
+    if (value && this.markdownText !== value) {
+        this.resultHtml.set(this.getResultHTML(value));
+    }
+    this._markdownText = value;
+}
+```
+
+The rendered HTML is a `computed` now and the input is a plain `input()`.
+
+## What it rewrites
+
+| Before                  | After                     |
+| ----------------------- | ------------------------- |
+| `markdown.markdownText` | `markdown.markdownText()` |
+
+Both on receivers explicitly typed `KbqMarkdown` and through template reference variables on
+`<kbq-markdown>`, in external and inline templates. Already-migrated reads are left alone, so the
+schematic is idempotent.
+
+## What it does _not_ do
+
+| Pattern                           | Manual migration                                               |
+| --------------------------------- | -------------------------------------------------------------- |
+| `markdown.markdownText = …`       | Bind `[markdownText]` in the template — the input is read-only |
+| `resultHtml.set(…)` in a subclass | Now a read-only `computed` — feed `markdownText` instead       |
+| `viewChild(KbqMarkdown)`          | The query is a signal too, so a read needs two calls           |
+
+## Notes with no call site to point at
+
+Both are consequences of the `if (value && …)` guard in the old setter.
+
+- **Clearing `markdownText` now clears the output.** The setter only re-rendered for a truthy value,
+  so setting it back to `null` or `''` left the previous HTML on screen indefinitely.
+- **The projected content is a standing fallback.** A `<kbq-markdown>` that both projects content and
+  binds `[markdownText]` falls back to the projected content whenever the input is empty, not just at
+  first render. The projected text is re-read when it changes, so content that only appears after the
+  first render is picked up too.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:markdown-signals --project my-app
+```
+
+Pass `--fix=false` to see what it would change without writing.

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

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * Data for the `markdown-signals` migration.
+ *
+ * `markdownText` was the component's only input and the last accessor input in the package. Its setter did
+ * the rendering, which is why the automated signal migration skipped it; the rendered HTML is a `computed`
+ * now and the input is a plain `input()`.
+ *
+ * - `markdown.markdownText` → `markdown.markdownText()` (value unchanged — auto-fixed)
+ * - `resultHtml` → a read-only `computed`; it was already `protected`, so only a subclass could ever name
+ *   it, and only a write to it changed (warn)
+ *
+ * The setter also never cleared what it had rendered, which the review fixed — see `SUMMARY`.
+ */
+/** Members of `KbqMarkdown` whose value is unchanged; a read must become a call. Auto-fixed. */
+const SIGNAL_MEMBERS = ['markdownText'];
+/** Signal-API methods reachable on a signal; a read followed by one is already migrated. */
+const SIGNAL_API_METHODS = new Set(['set', 'update', 'asReadonly', 'subscribe']);
+/** TypeScript type annotation that marks a receiver as a markdown component. */
+const MARKDOWN_TYPE = 'KbqMarkdown';
+/** Element selector whose template reference variables (`#ref`) point at a markdown component. */
+const MARKDOWN_ELEMENT = 'kbq-markdown';
+/** Import specifier that marks a file as a markdown consumer. */
+const MARKDOWN_PACKAGE = '@koobiq/components/markdown';
+const SUBCLASS_ANCHOR = 'extends\\s+KbqMarkdown\\b';
+const warnPatterns = [
+    {
+        anchor: SUBCLASS_ANCHOR,
+        pattern: '\\bresultHtml\\s*\\.\\s*set\\b',
+        message: 'KbqMarkdown.resultHtml is a read-only `computed` instead of a `WritableSignal`. It derives from ' +
+            '`markdownText` and the projected content, so a subclass that used to push HTML into it has to feed ' +
+            'the input instead.'
+    }
+];
+/**
+ * Reported for a read through a signal query, which is a signal holding the component: the read needs two
+ * calls rather than one. Emitted from the AST pass rather than a regex, so it follows the same receiver
+ * resolution as the rewrite and fires for an aliased import too.
+ *
+ * `viewChild()` without `.required` is typed `Signal<KbqMarkdown | undefined>`, so the safe spelling differs
+ * between the two forms - advising the required form for an optional query would hand the consumer a
+ * `TypeError`.
+ */
+const signalQueryMessage = (member, required) => `A signal query holds the component behind a call of its own, so reading \`${member}\` through it needs ` +
+    `two calls: \`this.markdown()${required ? '' : '?'}.${member}()\`. ` +
+    (required
+        ? 'Those reads are left untouched - migrate them by hand.'
+        : 'The query is optional, so keep the `?.`: it is `Signal<KbqMarkdown | undefined>`. Those reads are ' +
+            'left untouched - migrate them by hand.');
+/** Reported when a template renders the component but cannot be parsed, so nothing in it was inspected. */
+const UNPARSEABLE_TEMPLATE_MESSAGE = 'This template renders <kbq-markdown> but could not be parsed, so it was left untouched. Migrate reads ' +
+    'through its template reference variables by hand.';
+/**
+ * Reported when a file names `KbqMarkdown` in a type position the receiver pass cannot scope to a single
+ * identifier - a union, an array, a `QueryList<…>`, a cast, a return type - or reads the member in a shape
+ * the access pass cannot reach. Those reads are left alone, and staying silent reads as "nothing to do".
+ */
+const UNRESOLVED_RECEIVER_MESSAGE = 'KbqMarkdown is used here in a way this migration cannot resolve to a single receiver, so any signal ' +
+    'read through it was left untouched. Check these lines by hand:';
+/** Printed once per project, after the per-file reports. */
+const SUMMARY = [
+    '  Clearing `markdownText` now clears the rendered output. The setter only re-rendered for a truthy value, ' +
+        'so setting it back to null or an empty string left the previous HTML on screen indefinitely.',
+    '  A `<kbq-markdown>` that both projects content and binds `[markdownText]` falls back to the projected ' +
+        'content whenever the input is empty, not just at first render. The projected text is re-read when it ' +
+        'changes, so content that only appears after the first render is picked up too.'
+];
+
+exports.MARKDOWN_ELEMENT = MARKDOWN_ELEMENT;
+exports.MARKDOWN_PACKAGE = MARKDOWN_PACKAGE;
+exports.MARKDOWN_TYPE = MARKDOWN_TYPE;
+exports.SIGNAL_API_METHODS = SIGNAL_API_METHODS;
+exports.SIGNAL_MEMBERS = SIGNAL_MEMBERS;
+exports.SUMMARY = SUMMARY;
+exports.UNPARSEABLE_TEMPLATE_MESSAGE = UNPARSEABLE_TEMPLATE_MESSAGE;
+exports.UNRESOLVED_RECEIVER_MESSAGE = UNRESOLVED_RECEIVER_MESSAGE;
+exports.signalQueryMessage = signalQueryMessage;
+exports.warnPatterns = warnPatterns;