@zenit-hosting/zenit-ui 0.1.0

package/schematics/migrate-material/index.js

@@ -0,0 +1,463 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateMaterial = migrateMaterial;
+exports.mapOffset = mapOffset;
+/**
+ * `ng generate zenit-ui:migrate-material --path src/app/billing`.
+ *
+ * Rewrites the mechanical Angular Material usages below `--path` to zenit-ui
+ * (`mat-icon`, the button attributes, `matTooltip`, `mat-spinner`, static
+ * `mat-chip`, and the `imports` of the components) and reports everything it
+ * left alone. See `docs/migrate-material.md`.
+ *
+ * - Templates are parsed with `@angular/compiler`, component files with
+ *   TypeScript, each file once. Edits are made by source span against the
+ *   original text and applied in one pass per file, so indentation, attribute
+ *   order, quotes and line endings stay as they are.
+ * - A conversion that is not safe is skipped and reported, the rest of the file
+ *   is still converted. A template that does not parse is not touched at all.
+ * - Only files below `--path` are written. Stylesheets are counted, never edited.
+ * - A second run changes nothing.
+ */
+const schematics_1 = require("@angular-devkit/schematics");
+const utility_1 = require("@schematics/angular/utility");
+const typescript_1 = __importDefault(require("typescript"));
+const html_1 = require("../ng-add/html");
+const component_1 = require("./component");
+const report_1 = require("./report");
+const tables_1 = require("./tables");
+const template_1 = require("./template");
+const SKIPPED_FOLDERS = /^(node_modules|dist|\..*)$/;
+const STYLESHEET = /\.(css|scss|sass|less)$/;
+function migrateMaterial(options) {
+    return async (tree, context) => {
+        const rules = parseRules(options.rules);
+        const scope = await resolveScope(tree, options);
+        const dryRun = isDryRun(context);
+        const run = new Run(tree, scope, new Set(rules), dryRun);
+        const files = (scope.isFile ? [scope.path] : filesBelow(tree, scope.path)).filter((file) => /\.(ts|html)$/.test(file) || STYLESHEET.test(file));
+        for (const path of files.filter((file) => file.endsWith('.ts') && !file.endsWith('.d.ts'))) {
+            run.typescript(path);
+        }
+        for (const path of files.filter((file) => file.endsWith('.html'))) {
+            run.orphanTemplate(path);
+        }
+        for (const path of files.filter((file) => STYLESHEET.test(file))) {
+            run.stylesheet(path);
+        }
+        const report = (0, report_1.buildReport)(scope.path || '.', rules, dryRun, files.length, run.reports);
+        const markdown = (0, report_1.renderMarkdown)(report);
+        const target = normalize(options.report || 'zenit-migration-report.md');
+        const twin = target.replace(/(\.md)?$/, '.json');
+        // A run that changed nothing must not overwrite the report of the run that did:
+        // that one holds the review items, which cannot be found again afterwards.
+        const keep = report.totals.filesChanged === 0 && tree.exists(target);
+        // In a dry run the CLI discards the tree, and lists what would have been written.
+        if (!keep) {
+            write(tree, target, markdown);
+            write(tree, twin, (0, report_1.renderJson)(report));
+        }
+        const { totals, summary } = report;
+        const count = (kind) => Object.values(summary).reduce((sum, entry) => sum + entry[kind], 0);
+        context.logger.info(`zenit-ui: ${totals.filesScanned} files scanned below ${report.path}, ` +
+            `${totals.filesChanged} ${dryRun ? 'would change' : 'changed'}, ` +
+            `${totals.converted} spots converted, ${count('manual')} left for manual migration, ` +
+            `${count('review')} to review.\n` +
+            (dryRun
+                ? '  Dry run: nothing is written to disk, so the report follows here.'
+                : keep
+                    ? `  Nothing changed, so the existing report ${target} was kept. Use --print-report or --report <other file> to see the current state.`
+                    : `  Report: ${target} and ${twin}`));
+        if (options.printReport ?? dryRun) {
+            context.logger.info(markdown);
+        }
+    };
+}
+function parseRules(input) {
+    const names = (input || tables_1.RULES.join(','))
+        .split(',')
+        .map((name) => name.trim())
+        .filter(Boolean);
+    const unknown = names.filter((name) => !tables_1.RULES.includes(name));
+    if (unknown.length > 0 || names.length === 0) {
+        throw new schematics_1.SchematicsException(`Unknown rule(s) in --rules: ${unknown.join(', ') || '(none given)'}. Known rules: ${tables_1.RULES.join(', ')}.`);
+    }
+    return tables_1.RULES.filter((rule) => names.includes(rule));
+}
+/**
+ * ponytail: the dry-run flag is a CLI option that never reaches a schematic, so
+ * this reads the private `_dryRun` of the workflow and falls back to the command
+ * line. If a future devkit hides both, `--print-report` still prints the report.
+ */
+function isDryRun(context) {
+    const workflow = context.engine.workflow;
+    return (workflow?._dryRun === true ||
+        process.argv.some((argument) => /^(--dry-run|--dryRun|-d)(=true)?$/.test(argument)));
+}
+/** Workspace-relative, forward slashes, no leading or trailing slash; `''` is the workspace root. */
+function normalize(input) {
+    let path = input.trim().replace(/\\/g, '/');
+    const root = process.cwd().replace(/\\/g, '/').replace(/\/$/, '');
+    // An absolute path, as a shell completes it: with a drive letter on Windows, or below the
+    // working directory on Linux and macOS. A leading slash alone stays workspace-relative.
+    const absolute = /^[a-zA-Z]:\//.test(path) || path === root || path.startsWith(`${root}/`);
+    if (absolute) {
+        if (!path.toLowerCase().startsWith(`${root.toLowerCase()}/`) &&
+            path.toLowerCase() !== root.toLowerCase()) {
+            throw new schematics_1.SchematicsException(`"${input}" lies outside the workspace ${root}.`);
+        }
+        path = path.slice(root.length);
+    }
+    const parts = [];
+    for (const part of path.split('/')) {
+        if (part === '..') {
+            if (parts.length === 0) {
+                throw new schematics_1.SchematicsException(`"${input}" lies outside the workspace.`);
+            }
+            parts.pop();
+        }
+        else if (part !== '' && part !== '.') {
+            parts.push(part);
+        }
+    }
+    return parts.join('/');
+}
+async function resolveScope(tree, options) {
+    if (!options.path?.trim()) {
+        throw new schematics_1.SchematicsException('--path is required: the folder or file to migrate.');
+    }
+    const candidates = [normalize(options.path)];
+    let projectRoot;
+    if (options.project) {
+        const workspace = await (0, utility_1.readWorkspace)(tree);
+        const project = workspace.projects.get(options.project);
+        if (!project) {
+            throw new schematics_1.SchematicsException(`Project "${options.project}" was not found in the workspace. Known projects: ` +
+                `${[...workspace.projects.keys()].join(', ') || '(none)'}.`);
+        }
+        projectRoot = normalize(project.root);
+        const sourceRoot = normalize(project.sourceRoot ?? `${project.root}/src`);
+        candidates.push(normalize(`${sourceRoot}/${options.path}`));
+    }
+    for (const path of candidates) {
+        const isFile = tree.exists(`/${path}`);
+        if (!isFile) {
+            // getDir() throws for a file, and an empty directory is what a missing one looks like.
+            const directory = tree.getDir(`/${path}`);
+            if (directory.subfiles.length === 0 && directory.subdirs.length === 0) {
+                continue;
+            }
+        }
+        if (path.split('/').some((part) => SKIPPED_FOLDERS.test(part))) {
+            throw new schematics_1.SchematicsException(`"${path}" is not source code of the workspace.`);
+        }
+        if (projectRoot && path !== projectRoot && !path.startsWith(`${projectRoot}/`)) {
+            // (a project at the workspace root has the root '' and contains everything)
+            throw new schematics_1.SchematicsException(`"${path}" lies outside the project "${options.project}" (${projectRoot || '.'}).`);
+        }
+        return { path, isFile };
+    }
+    throw new schematics_1.SchematicsException(`--path "${options.path}" was not found (looked for ${candidates.map((path) => `"${path}"`).join(' and ')}).`);
+}
+/** All files below a folder, sorted, without `node_modules`, `dist` and dot folders. */
+function filesBelow(tree, folder) {
+    const out = [];
+    const walk = (path) => {
+        const directory = tree.getDir(`/${path}`);
+        for (const file of directory.subfiles) {
+            out.push(path ? `${path}/${file}` : file);
+        }
+        for (const sub of directory.subdirs) {
+            if (!SKIPPED_FOLDERS.test(sub)) {
+                walk(path ? `${path}/${sub}` : sub);
+            }
+        }
+    };
+    walk(folder);
+    return out.sort();
+}
+function write(tree, path, content) {
+    if (tree.exists(path)) {
+        tree.overwrite(path, content);
+    }
+    else {
+        tree.create(path, content);
+    }
+}
+/** One run over the scope. Every file is read, parsed and written at most once. */
+class Run {
+    tree;
+    scope;
+    rules;
+    dryRun;
+    reports = [];
+    templates = new Map();
+    constructor(tree, scope, rules, dryRun) {
+        this.tree = tree;
+        this.scope = scope;
+        this.rules = rules;
+        this.dryRun = dryRun;
+    }
+    inScope(path) {
+        return this.scope.isFile
+            ? path === this.scope.path
+            : this.scope.path === '' || path.startsWith(`${this.scope.path}/`);
+    }
+    /** The text with its BOM, `undefined` for a file that is not valid UTF-8. */
+    read(path) {
+        const buffer = this.tree.read(`/${path}`);
+        try {
+            return buffer
+                ? new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(buffer)
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Applies the edits of one file in one pass and files the report entry. */
+    finish(path, text, edits, findings, entry) {
+        let sorted = (0, template_1.sortEdits)(edits);
+        if (sorted.some((edit, index) => index > 0 && edit.start < sorted[index - 1].end)) {
+            // Cannot happen with the planners as they are; if it does, the file stays as it is.
+            sorted = [];
+            findings = [
+                ...findings.filter((finding) => finding.kind === 'manual'),
+                {
+                    offset: 0,
+                    rule: 'imports',
+                    kind: 'manual',
+                    code: 'unsafe-edit',
+                    reason: 'The planned edits of this file overlap, so none of them was applied.',
+                    fix: 'Migrate this file by hand.',
+                },
+            ];
+            entry = { ...entry, converted: {} };
+        }
+        const output = (0, html_1.applyEdits)(text, sorted);
+        if (output !== text) {
+            this.tree.overwrite(`/${path}`, output);
+        }
+        // Lines refer to what is on disk after the run: the new text, or the old one in a dry run.
+        const shown = this.dryRun ? text : output;
+        const starts = lineStarts(shown);
+        this.reports.push({
+            path,
+            status: entry.unparsed ? 'unparsed' : output !== text ? 'changed' : 'unchanged',
+            converted: entry.converted,
+            remaining: entry.remaining,
+            findings: findings.map(({ offset, rule, kind, code, reason, fix }) => ({
+                ...position(starts, this.dryRun ? offset : mapOffset(offset, sorted)),
+                rule,
+                kind,
+                code,
+                reason,
+                fix,
+            })),
+        });
+    }
+    unparsable(what, error, offset = 0) {
+        return {
+            offset,
+            rule: 'parse',
+            kind: 'manual',
+            code: 'template-unparsable',
+            reason: `${what} does not parse (${error}), so nothing in it was touched.`,
+            fix: 'Fix the template, then run the schematic again.',
+        };
+    }
+    /** An external template: migrated once, whoever asks first. */
+    template(path) {
+        if (this.templates.has(path)) {
+            return this.templates.get(path);
+        }
+        const text = this.read(path);
+        if (text === undefined) {
+            return undefined;
+        }
+        const result = (0, template_1.migrateTemplate)(text, { rules: this.rules });
+        this.templates.set(path, result);
+        this.finish(path, text, result.edits, result.error ? [this.unparsable('The template', result.error)] : result.findings, { converted: result.converted, remaining: result.remaining, unparsed: !!result.error });
+        return result;
+    }
+    /** A template below `--path` that no component below `--path` names. */
+    orphanTemplate(path) {
+        if (this.templates.has(path)) {
+            return;
+        }
+        const result = this.template(path);
+        if (result && !result.error && this.rules.has('imports') && result.zenit.length > 0) {
+            this.reports.at(-1)?.findings.push({
+                line: 1,
+                column: 1,
+                rule: 'imports',
+                kind: 'manual',
+                code: 'imports-owner-outside-path',
+                reason: 'No component below --path names this template in templateUrl, so no "imports" were updated for it.',
+                fix: `In the component that owns this template: add ${result.zenit.join(', ')} from 'zenit-ui' and remove the Material modules whose selectors are gone.`,
+            });
+        }
+    }
+    typescript(path) {
+        const text = this.read(path);
+        if (text === undefined) {
+            return;
+        }
+        if (path.endsWith('.spec.ts')) {
+            const named = [...new Set(text.match(/\bMat[A-Z]\w*(Module|Harness)\b/g) ?? [])].sort();
+            if (named.length > 0 && this.rules.has('imports')) {
+                this.finish(path, text, [], [
+                    {
+                        offset: text.search(/\bMat[A-Z]\w*(Module|Harness)\b/),
+                        rule: 'imports',
+                        kind: 'manual',
+                        code: 'imports-spec',
+                        reason: `The spec names ${named.join(', ')}. Spec files are never edited.`,
+                        fix: 'Update the TestBed imports and the harnesses once the component is migrated.',
+                    },
+                ], { converted: {}, remaining: {} });
+            }
+            return;
+        }
+        if (!/@Component\s*\(/.test(text)) {
+            return;
+        }
+        const source = typescript_1.default.createSourceFile(path, text, typescript_1.default.ScriptTarget.Latest, true);
+        const edits = [];
+        const findings = [];
+        const converted = {};
+        const remaining = {};
+        const usages = [];
+        for (const component of (0, component_1.findComponents)(source)) {
+            const manual = (code, reason, fix) => findings.push({
+                offset: component.offset,
+                rule: 'parse',
+                kind: 'manual',
+                code,
+                reason,
+                fix,
+            });
+            if (component.inline) {
+                const { start, end, delimiter } = component.inline;
+                const result = (0, template_1.migrateTemplate)(text.slice(start, end), {
+                    rules: this.rules,
+                    quote: delimiter === '"' ? "'" : '"',
+                    plainString: delimiter !== '`',
+                });
+                if (result.error) {
+                    findings.push(this.unparsable(`The inline template of ${component.name}`, result.error, start));
+                    continue;
+                }
+                edits.push(...result.edits.map((edit) => ({
+                    ...edit,
+                    start: edit.start + start,
+                    end: edit.end + start,
+                })));
+                findings.push(...result.findings.map((finding) => ({ ...finding, offset: finding.offset + start })));
+                for (const [rule, count] of Object.entries(result.converted)) {
+                    converted[rule] = (converted[rule] ?? 0) + count;
+                }
+                for (const [name, count] of Object.entries(result.remaining)) {
+                    remaining[name] = (remaining[name] ?? 0) + count;
+                }
+                usages.push([component, result]);
+            }
+            else if (component.inlineProblem) {
+                manual('template-not-literal', `${component.name}: ${component.inlineProblem} It was not read, and the "imports" of the component were left alone.`, 'Migrate this template by hand, or move it into an .html file and run the schematic again.');
+            }
+            else if (component.templateUrl !== undefined) {
+                const folder = path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '';
+                let url;
+                try {
+                    url = normalize(`${folder}/${component.templateUrl}`);
+                }
+                catch {
+                    url = undefined;
+                }
+                if (url === undefined || !this.tree.exists(`/${url}`)) {
+                    manual('template-missing', `${component.name}: the template ${component.templateUrl} was not found.`, 'Check the templateUrl.');
+                }
+                else if (!this.inScope(url)) {
+                    manual('template-outside-path', `${component.name}: the template ${url} lies outside --path and was not touched, nor were the "imports" of the component.`, 'Run the schematic with a --path that contains both files.');
+                }
+                else {
+                    const result = this.template(url);
+                    if (result && !result.error) {
+                        usages.push([component, result]);
+                    }
+                }
+            }
+        }
+        if (this.rules.has('imports') && usages.length > 0) {
+            const planned = (0, component_1.planImports)(source, usages);
+            edits.push(...planned.edits);
+            findings.push(...planned.findings);
+            if (planned.changed > 0) {
+                converted.imports = planned.changed;
+            }
+        }
+        this.finish(path, text, edits, findings, { converted, remaining });
+    }
+    stylesheet(path) {
+        const text = this.read(path);
+        if (text === undefined) {
+            return;
+        }
+        // ponytail: plain pattern counts, comments included. The number is a burn-down, not a lint.
+        const styleDebt = {};
+        for (const [label, pattern] of Object.entries(tables_1.STYLE_DEBT)) {
+            styleDebt[label] = text.match(pattern)?.length ?? 0;
+        }
+        if (Object.values(styleDebt).some((count) => count > 0)) {
+            this.reports.push({
+                path,
+                status: 'unchanged',
+                converted: {},
+                findings: [],
+                remaining: {},
+                styleDebt,
+            });
+        }
+    }
+}
+function lineStarts(text) {
+    const starts = [0];
+    for (let index = text.indexOf('\n'); index !== -1; index = text.indexOf('\n', index + 1)) {
+        starts.push(index + 1);
+    }
+    return starts;
+}
+/** 1-based line and column of an offset. */
+function position(starts, offset) {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (starts[middle] <= offset) {
+            low = middle;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return { line: low + 1, column: offset - starts[low] + 1 };
+}
+/** Where an offset of the original text ends up after the (sorted) edits. */
+function mapOffset(offset, edits) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (edit.end <= offset && edit.start < offset) {
+            delta += edit.text.length - (edit.end - edit.start);
+        }
+        else if (edit.start < offset) {
+            return edit.start + delta; // inside a replaced span
+        }
+        else {
+            break;
+        }
+    }
+    return offset + delta;
+}

package/schematics/migrate-material/report.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReport = buildReport;
+exports.renderJson = renderJson;
+exports.renderMarkdown = renderMarkdown;
+/**
+ * The report of `migrate-material`, as data, as JSON and as Markdown. Both
+ * renderings are deterministic: no timestamps, files and findings sorted, paths
+ * workspace-relative with forward slashes.
+ */
+const tables_1 = require("./tables");
+function buildReport(path, rules, dryRun, filesScanned, files) {
+    const listed = files
+        .filter((file) => file.status !== 'unchanged' ||
+        file.findings.length > 0 ||
+        Object.keys(file.remaining).length > 0 ||
+        file.styleDebt)
+        .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const summary = {};
+    const row = (rule) => (summary[rule] ??= { converted: 0, manual: 0, review: 0, info: 0 });
+    tables_1.RULES.forEach(row);
+    const remaining = {};
+    for (const file of listed) {
+        for (const [rule, count] of Object.entries(file.converted)) {
+            row(rule).converted += count;
+        }
+        for (const finding of file.findings) {
+            row(finding.rule)[finding.kind] += 1;
+        }
+        for (const [name, count] of Object.entries(file.remaining)) {
+            remaining[name] = (remaining[name] ?? 0) + count;
+        }
+        file.findings.sort((a, b) => a.line - b.line || a.column - b.column || a.code.localeCompare(b.code));
+    }
+    return {
+        schema: 1,
+        path,
+        rules,
+        dryRun,
+        totals: {
+            filesScanned,
+            filesChanged: listed.filter((file) => file.status === 'changed').length,
+            converted: Object.values(summary).reduce((sum, entry) => sum + entry.converted, 0),
+            findings: listed.reduce((sum, file) => sum + file.findings.length, 0),
+        },
+        summary,
+        remaining: sortedCounts(remaining),
+        files: listed,
+    };
+}
+function sortedCounts(counts) {
+    return Object.keys(counts)
+        .sort()
+        .map((name) => ({ name, count: counts[name], replacement: (0, tables_1.replacementFor)(name) }));
+}
+function renderJson(report) {
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+/** A table cell: one line, no pipe that would end the cell. */
+function cell(text) {
+    return text.replace(/\s+/g, ' ').replace(/\|/g, '\\|');
+}
+function renderMarkdown(report) {
+    const out = [
+        '# zenit-ui migration report',
+        '',
+        `Path \`${report.path}\`, rules ${report.rules.join(', ')}. ` +
+            (report.dryRun
+                ? 'Dry run: nothing was written, lines refer to the files as they are.'
+                : 'Applied: lines refer to the files after the run.'),
+        '',
+        `${report.totals.filesScanned} files scanned, ${report.totals.filesChanged} changed, ` +
+            `${report.totals.converted} spots converted, ${report.totals.findings} findings.`,
+        '',
+        '- **manual**: not converted, a human has to do it.',
+        '- **review**: converted, but something changed that needs a look.',
+        '- **info**: converted, what was dropped has no effect in zenit-ui.',
+        '',
+        '## Summary',
+        '',
+        '| Rule | Converted | Manual | Review | Info |',
+        '| --- | ---: | ---: | ---: | ---: |',
+        ...Object.keys(report.summary).map((rule) => {
+            const entry = report.summary[rule];
+            return `| ${rule} | ${entry.converted} | ${entry.manual} | ${entry.review} | ${entry.info} |`;
+        }),
+        '',
+    ];
+    if (report.remaining.length > 0) {
+        out.push('## Left for manual migration', '', 'Material tags and attributes still in the templates after this run.', '', '| Selector | Count | zenit-ui replacement |', '| --- | ---: | --- |', ...report.remaining.map(({ name, count, replacement }) => `| \`${name}\` | ${count} | ${cell(replacement)} |`), '');
+    }
+    const styles = report.files.filter((file) => file.styleDebt);
+    if (styles.length > 0) {
+        const columns = Object.keys(styles[0].styleDebt ?? {});
+        out.push('## Style debt', '', 'Stylesheets are never edited. Every count is a place where application CSS reaches into Material.', '', `| File | ${columns.map(cell).join(' | ')} |`, `| --- | ${columns.map(() => '---:').join(' | ')} |`, ...styles.map((file) => `| \`${file.path}\` | ${columns.map((column) => file.styleDebt?.[column] ?? 0).join(' | ')} |`), '');
+    }
+    const files = report.files.filter((file) => !file.styleDebt);
+    if (files.length > 0) {
+        out.push('## Files', '');
+    }
+    for (const file of files) {
+        const converted = Object.entries(file.converted)
+            .filter(([, count]) => count > 0)
+            .map(([rule, count]) => `${rule} ${count}`);
+        out.push(`### \`${file.path}\``, '', `${file.status}${converted.length ? `, converted: ${converted.join(', ')}` : ''}`, '');
+        const rows = file.findings.filter((finding) => finding.kind !== 'info');
+        if (rows.length > 0) {
+            out.push('| Line:Col | Rule | Kind | Code | Reason | Suggested fix |', '| --- | --- | --- | --- | --- | --- |', ...rows.map((f) => `| ${f.line}:${f.column} | ${f.rule} | ${f.kind} | ${f.code} | ${cell(f.reason)} | ${cell(f.fix)} |`), '');
+        }
+        // Harmless drops are many and alike: one line per code instead of one row each.
+        const infos = file.findings.filter((finding) => finding.kind === 'info');
+        for (const code of [...new Set(infos.map((finding) => finding.code))].sort()) {
+            const lines = infos.filter((finding) => finding.code === code).map((finding) => finding.line);
+            out.push(`- info \`${code}\` x${lines.length}, lines ${lines.join(', ')}`);
+        }
+        if (infos.length > 0) {
+            out.push('');
+        }
+        const remaining = sortedCounts(file.remaining);
+        if (remaining.length > 0) {
+            out.push(`Left: ${remaining.map(({ name, count }) => `\`${name}\` x${count}`).join(', ')}`, '');
+        }
+    }
+    return `${out.join('\n').replace(/\n+$/, '')}\n`;
+}

package/schematics/migrate-material/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/schematics/migrate-material/schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SchematicsZenitUiMigrateMaterial",
+  "title": "zenit-ui migrate-material schema",
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Workspace-relative folder or file to migrate. Only files under it are written.",
+      "x-prompt": "Which folder or file should be migrated (workspace-relative, for example src/app/billing)?"
+    },
+    "project": {
+      "type": "string",
+      "description": "Project the path belongs to. The path may then also be given relative to the project's sourceRoot, and a path outside the project is refused."
+    },
+    "report": {
+      "type": "string",
+      "default": "zenit-migration-report.md",
+      "description": "Workspace-relative path of the Markdown report. A JSON twin with the same name and the extension .json is written next to it."
+    },
+    "rules": {
+      "type": "string",
+      "default": "icon,button,tooltip,spinner,chip,imports",
+      "description": "Comma-separated subset of the rules to run: icon, button, tooltip, spinner, chip, imports."
+    },
+    "printReport": {
+      "type": "boolean",
+      "description": "Print the full Markdown report to the console. Default: only in a dry run, where no file is written."
+    }
+  },
+  "required": ["path"]
+}