uql-codemod 0.48.1 → 0.49.0

package/dist/classOptions.js

@@ -0,0 +1,240 @@
+import ts from 'typescript';
+import { original } from './edits.js';
+import { memberKey } from './keyMaps.js';
+import { arrayElements, decoratorName, decoratorsOf, indentOf, indentUnit, lineStartOf, namedProperty, objectLiteral, } from './syntax.js';
+/** The class decorators `@Entity`'s options took over, each with the option its entries go under. */
+const FOLDED = { Index: 'indexes', Trigger: 'triggers', Filter: 'filters' };
+const isFolded = (name) => name !== undefined && Object.hasOwn(FOLDED, name);
+const slotEntries = (entries) => new Map([...entries].map(([option, { before, after }]) => [option, [...before, ...after]]));
+/**
+ * Folds `@Index`, `@Trigger` and `@Filter` into the class's `@Entity` options, `indexes`, `triggers` and `filters`.
+ * Triggers keep the order they register in, which is the order they run in: decorators apply bottom-up, so those
+ * below `@Entity` go ahead of its own and those above after them. Indexes and filters, whose order means nothing,
+ * follow `@Entity`'s own in the order written. A class with no `@Entity` becomes `@Entity({ abstract: true, ... })`.
+ */
+export function foldClassDecorators(node, ctx) {
+    const decorators = decoratorsOf(node);
+    const unit = indentUnit(node.getSourceFile());
+    const entity = decorators.find((decorator) => decoratorName(decorator) === 'Entity');
+    const at = entity ? decorators.indexOf(entity) : -1;
+    const folded = decorators.flatMap((decorator, index) => {
+        const name = decoratorName(decorator);
+        return isFolded(name) && ts.isCallExpression(decorator.expression)
+            ? [{ decorator, call: decorator.expression, name, index }]
+            : [];
+    });
+    if (!folded.length) {
+        return;
+    }
+    const call = entity && entityCall(entity, ctx);
+    const options = call && entityOptions(call, ctx);
+    if (call === null || options === null) {
+        return;
+    }
+    const triggers = folded.filter(({ name }) => name === 'Trigger');
+    const applied = (above) => triggers.filter(({ index }) => index < at === above).toReversed();
+    const before = applied(false);
+    const after = [...applied(true), ...folded.filter(({ name }) => name !== 'Trigger')];
+    const entries = new Map();
+    for (const [list, side] of [
+        [before, 'before'],
+        [after, 'after'],
+    ]) {
+        for (const { call, name, decorator } of list) {
+            const written = entriesOf(name, call, decorator, ctx);
+            if (!written) {
+                return;
+            }
+            const comments = commentTexts(decorator);
+            const slot = entries.get(FOLDED[name]) ?? { before: [], after: [] };
+            slot[side].push(...written.map((parts, index) => ({ parts, comments: index ? [] : comments })));
+            entries.set(FOLDED[name], slot);
+        }
+    }
+    for (const { decorator, name } of folded) {
+        ctx.edits.push(removedDecorator(decorator));
+        ctx.rewritten[name] += 1;
+    }
+    if (!call) {
+        const first = removedDecorator(folded[0].decorator);
+        const indent = indentOf(folded[0].decorator);
+        const text = ['@Entity({ abstract: true, ', ...optionParts(slotEntries(entries), indent, unit), ' })'];
+        const onItsLine = node.getSourceFile().text.slice(first.start, first.end).endsWith('\n');
+        ctx.edits.push({
+            start: first.start,
+            end: first.start,
+            text: onItsLine ? [indent, ...text, '\n'] : [...text, ' '],
+        });
+        ctx.imports.set('Entity', 'the abstract base its class decorators moved into');
+        return;
+    }
+    ctx.edits.push(...entityEdits(call, options, entries, unit));
+}
+/** `@Entity`'s call, or `null`, reported, where it is written uncalled and so takes no options. */
+function entityCall(entity, ctx) {
+    if (ts.isCallExpression(entity.expression)) {
+        return entity.expression;
+    }
+    ctx.report(entity, "call '@Entity()' to move '@Index', '@Trigger' and '@Filter' into its options");
+    return null;
+}
+/** `@Entity`'s options literal, `undefined` where it takes none, or `null`, reported, where it cannot be read. */
+function entityOptions(call, ctx) {
+    const [first] = call.arguments;
+    if (!first) {
+        return undefined;
+    }
+    const literal = objectLiteral(first);
+    if (!literal) {
+        ctx.report(call, "move '@Index', '@Trigger' and '@Filter' into '@Entity' options this cannot read");
+        return null;
+    }
+    return literal;
+}
+/** The entries one decorator registers, or nothing, reported, where it cannot say them as an option. */
+function entriesOf(name, call, decorator, ctx) {
+    const [first, second] = call.arguments;
+    if (name === 'Trigger') {
+        return call.arguments.map((trigger) => [original(trigger)]);
+    }
+    if (name === 'Index') {
+        if (!first) {
+            ctx.report(decorator, "move this '@Index' into '@Entity({ indexes })' by hand: it names no columns");
+            return undefined;
+        }
+        const props = objectLiteral(second);
+        const rest = props
+            ? props.properties.flatMap((prop) => [', ', original(prop)])
+            : second
+                ? [', ...', original(second)]
+                : [];
+        return [['{ columns: ', original(first), ...rest, ' }']];
+    }
+    if (!first || !ts.isStringLiteralLike(first) || !second) {
+        ctx.report(decorator, "move this '@Filter' into '@Entity({ filters })' by hand: its name is not a string");
+        return undefined;
+    }
+    return [[memberKey(first.text), ': ', original(second)]];
+}
+/** Each option's entries as comma-separated properties, a list holding a comment one entry a line. */
+function optionParts(entries, indent, unit) {
+    return [...entries].flatMap(([option, list], index) => [
+        ...(index ? [', '] : []),
+        ...bracketed(option, list, indent, unit),
+    ]);
+}
+function bracketed(option, list, indent, unit) {
+    const [open, close] = option === 'filters' ? ['{', '}'] : ['[', ']'];
+    if (list.length < 2 && !list.some(({ comments }) => comments.length)) {
+        const pad = option === 'filters' ? ' ' : '';
+        return [`${option}: ${open}${pad}`, ...joined(list, ', '), `${pad}${close}`];
+    }
+    const inner = `${indent}${unit}`;
+    return [`${option}: ${open}\n`, ...lines(list, inner), `${indent}${close}`];
+}
+function joined(list, separator) {
+    return list.flatMap(({ parts }, index) => (index ? [separator, ...parts] : [...parts]));
+}
+/** Each entry on its own line under `indent`, its comments on the lines above it. */
+function lines(list, indent) {
+    return list.flatMap(({ parts, comments }) => [
+        ...comments.flatMap((comment) => [indent, comment, '\n']),
+        indent,
+        ...parts,
+        ',\n',
+    ]);
+}
+/**
+ * The line comments directly above `decorator`, which say something of it: a run with no blank line before the
+ * decorator. A doc comment, or one a blank line parts from it, is the class's and stays where it is.
+ */
+function decoratorComments(decorator) {
+    const text = decorator.getSourceFile().text;
+    const ranges = ts.getLeadingCommentRanges(text, decorator.pos) ?? [];
+    const kept = [];
+    let next = decorator.getStart();
+    for (const range of ranges.toReversed()) {
+        const between = text.slice(range.end, next);
+        if (range.kind !== ts.SyntaxKind.SingleLineCommentTrivia || /\n\s*\n/.test(between))
+            break;
+        kept.unshift(range);
+        next = range.pos;
+    }
+    return kept;
+}
+/** A comment closing the decorator's line, which says something of it too. */
+function trailingComments(decorator) {
+    const text = decorator.getSourceFile().text;
+    return (ts.getTrailingCommentRanges(text, decorator.getEnd()) ?? []).filter(({ kind }) => kind === ts.SyntaxKind.SingleLineCommentTrivia);
+}
+/** The comments the decorator's entry carries: those above it, then the one closing its line. */
+function commentTexts(decorator) {
+    const text = decorator.getSourceFile().text;
+    return [...decoratorComments(decorator), ...trailingComments(decorator)].map(({ pos, end }) => text.slice(pos, end));
+}
+/** The edits writing `entries` into `@Entity`'s options, each option's own list merged where it states one. */
+function entityEdits(call, options, entries, unit) {
+    const indent = indentOf(call);
+    if (!options) {
+        const at = call.getEnd() - 1;
+        return [{ start: at, end: at, text: ['{ ', ...optionParts(slotEntries(entries), indent, unit), ' }'] }];
+    }
+    const edits = [];
+    const added = new Map();
+    for (const [option, slot] of entries) {
+        const stated = namedProperty(options, option);
+        const value = stated && ts.isPropertyAssignment(stated) ? stated.initializer : undefined;
+        const list = value && (ts.isArrayLiteralExpression(value) ? arrayElements(value) : objectLiteral(value)?.properties);
+        if (!value || !list) {
+            added.set(option, [...slot.before, ...slot.after]);
+            continue;
+        }
+        const open = value.getStart() + 1;
+        const close = value.getEnd() - 1;
+        const inner = `${indentOf(value)}${unit}`;
+        const commented = (side) => side.some(({ comments }) => comments.length);
+        if (slot.before.length) {
+            const text = commented(slot.before)
+                ? ['\n', ...lines(slot.before, inner), inner]
+                : [...joined(slot.before, ', '), ...(list.length ? [', '] : [])];
+            edits.push({ start: open, end: open, text });
+        }
+        if (slot.after.length) {
+            const end = list.length ? list[list.length - 1].getEnd() : close;
+            const lead = list.length || slot.before.length ? ', ' : '';
+            const text = commented(slot.after)
+                ? slot.after.flatMap(({ parts, comments }, index) => [
+                    index || lead ? ',\n' : '\n',
+                    ...comments.flatMap((comment) => [inner, comment, '\n']),
+                    inner,
+                    ...parts,
+                ])
+                : [lead, ...joined(slot.after, ', ')];
+            edits.push({ start: end, end, text });
+        }
+    }
+    if (added.size) {
+        const last = options.properties.at(-1);
+        const at = last ? last.getEnd() : options.getEnd() - 1;
+        const parts = optionParts(added, indent, unit);
+        edits.push({ start: at, end: at, text: last ? [', ', ...parts] : [' ', ...parts, ' '] });
+    }
+    return edits;
+}
+/** Removes a decorator, with its line where it stands alone on one, or the blank after it where it shares one. */
+function removedDecorator(decorator) {
+    const text = decorator.getSourceFile().text;
+    const start = decoratorComments(decorator)[0]?.pos ?? decorator.getStart();
+    const end = trailingComments(decorator).at(-1)?.end ?? decorator.getEnd();
+    const lineStart = lineStartOf(text, start);
+    const lineEnd = text.indexOf('\n', end);
+    // A class follows its decorators, so the line of one standing alone ends before the file does.
+    const alone = text.slice(lineStart, start).trim() === '' && text.slice(end, lineEnd).trim() === '';
+    if (alone) {
+        return { start: lineStart, end: lineEnd + 1, text: '' };
+    }
+    const after = /\s*/y;
+    after.lastIndex = end;
+    after.exec(text);
+    return { start, end: after.lastIndex, text: '' };
+}

package/dist/columnMethods.d.ts

@@ -0,0 +1,11 @@
+/** How an option's value becomes a column method, or `undefined` where it cannot be written as one. */
+export type OptionMethod<R extends string | undefined = string> = readonly [
+    option: string,
+    method: (value: string) => R
+];
+/** The option's value passed to `method`: `.length(80)`. */
+export declare const call: (method: string) => (value: string) => string;
+/** A flag as its method where it is `true`, nothing where `false`, and `undefined` where no literal says. */
+export declare const flag: (method: string) => (value: string) => string | undefined;
+/** {@link flag}, its value passed to the method where it is no literal. */
+export declare const flagOrCall: (method: string) => (value: string) => string;

package/dist/columnMethods.js

@@ -0,0 +1,6 @@
+/** The option's value passed to `method`: `.length(80)`. */
+export const call = (method) => (value) => `.${method}(${value})`;
+/** A flag as its method where it is `true`, nothing where `false`, and `undefined` where no literal says. */
+export const flag = (method) => (value) => value === 'true' ? `.${method}()` : value === 'false' ? '' : undefined;
+/** {@link flag}, its value passed to the method where it is no literal. */
+export const flagOrCall = (method) => (value) => flag(method)(value) ?? call(method)(value);

package/dist/columnRefs.js

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 import { constructedType, memberNames, ownerOf, propertyNames } from './context.js';
 import { inserted, replaced } from './edits.js';
-import { isRaw } from './entitySql.js';
+import { isSqlCall } from './entitySql.js';
 import { uqlImport, usesOf } from './imports.js';
 import { memberAccess } from './keyMaps.js';
-import { identifierText, propertyKey, propertyValue } from './syntax.js';
+import { identifierText, mentions, propertyKey, propertyValue } from './syntax.js';
 /**
  * Rewrites each `col('x')` into the ref it names - `product.x` in a `computed` callback, `refs(Item).x` in a
  * statement - where the entity its SQL renders against, and a member named `x`, can be told from here. Every
@@ -19,7 +19,7 @@ export function rewriteColumnRefs(ctx) {
     const unread = [];
     for (const use of usesOf(ctx.source, element.name, ctx.checker)) {
         const call = ts.isCallExpression(use.parent) && use.parent.expression === use ? use.parent : undefined;
-        const sql = call && ts.findAncestor(call, isRaw);
+        const sql = call && ts.findAncestor(call, (node) => isSqlCall(node, ctx.checker));
         const option = sql?.parent;
         const owner = option && ts.isPropertyAssignment(option) && isComputedOption(option) ? computedOwner(option) : undefined;
         const edit = call && !owner ? statementRefEdit(call, ctx) : undefined;
@@ -85,13 +85,6 @@ function columnMember(call, members) {
     const [name] = call.arguments;
     return call.arguments.length === 1 && ts.isStringLiteralLike(name) && members.has(name.text) ? name.text : undefined;
 }
-/** Whether `node` reads a binding named `name`, which a callback parameter of that name would shadow. */
-function mentions(node, name) {
-    if (ts.isIdentifier(node)) {
-        return node.text === name && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node);
-    }
-    return ts.forEachChild(node, (child) => mentions(child, name) || undefined) ?? false;
-}
 /**
  * The entity a statement's SQL renders against at `node`: the one its query names, or a relation a `$populate`
  * reads there. Nothing where a function or a relation filter in between opens a scope of its own.

package/dist/context.d.ts

@@ -1,5 +1,11 @@
 import ts from 'typescript';
 import type { Edit } from './edits.js';
+/**
+ * Each name whose import goes once every use was rewritten: `expr` defaults, and the class decorators folded into
+ * `@Entity`.
+ */
+export declare const REWRITTEN: readonly ["expr", "Index", "Trigger", "Filter"];
+type Rewritten = (typeof REWRITTEN)[number];
 /** What a rewrite of one file reads and writes. */
 export type Context = {
     readonly source: ts.SourceFile;
@@ -11,16 +17,22 @@ export type Context = {
     readonly notes: string[];
     /** Names written that the file has to import from `uql-orm`, each with what it was written for. */
     readonly imports: Map<string, string>;
-    /** Uses rewritten of each name whose import goes once every use was: `Relation<T>` unwrapped, `expr` defaults. */
-    readonly rewritten: {
-        Relation: number;
-        expr: number;
-    };
+    /** Uses rewritten of each of `REWRITTEN`. */
+    readonly rewritten: Record<Rewritten, number>;
     /** Records what needs a human, at `node`. */
     readonly report: (node: ts.Node, message: string) => void;
     /** Records a rewrite that is correct but worth a second look, at `node`. */
     readonly note: (node: ts.Node, message: string) => void;
 };
+/** `file:line` of offset `at` in `source`. */
+export declare function locationAt(source: ts.SourceFile, at: number): string;
+/** A finding before it is located: the node it is about, and what to do. */
+export type Finding = {
+    readonly node: ts.Node;
+    readonly message: string;
+};
+/** Findings in source order, each as `file:line: message`, the line `locate` reads its offset at. */
+export declare function formatFindings(findings: readonly Finding[], locate: (at: number) => string): string[];
 export declare function createContext(source: ts.SourceFile, checker: ts.TypeChecker, strictNullChecks: boolean): Context;
 /** The entity a definition describes: the parameter its callbacks are named after, and the node naming it. */
 export type Owner = {
@@ -36,3 +48,4 @@ export declare function instanceTypeOf(node: ts.Node, checker: ts.TypeChecker):
 export declare function propertyNames(type: ts.Type): ReadonlySet<string>;
 /** The names of the members of the entity `node` declares or names. */
 export declare function memberNames(node: ts.Node, checker: ts.TypeChecker): ReadonlySet<string>;
+export {};

package/dist/context.js

@@ -1,10 +1,28 @@
 import ts from 'typescript';
 import { paramFor } from './keyMaps.js';
 import { identifierText } from './syntax.js';
+/**
+ * Each name whose import goes once every use was rewritten: `expr` defaults, and the class decorators folded into
+ * `@Entity`.
+ */
+export const REWRITTEN = ['expr', 'Index', 'Trigger', 'Filter'];
+/** Where `node` is, as a finding names it: `file:line`. */
+function locationOf(node) {
+    return locationAt(node.getSourceFile(), node.getStart());
+}
+/** `file:line` of offset `at` in `source`. */
+export function locationAt(source, at) {
+    return `${source.fileName}:${source.getLineAndCharacterOfPosition(at).line + 1}`;
+}
+/** Findings in source order, each as `file:line: message`, the line `locate` reads its offset at. */
+export function formatFindings(findings, locate) {
+    return findings
+        .toSorted((a, b) => a.node.getStart() - b.node.getStart())
+        .map(({ node, message }) => `${locate(node.getStart())}: ${message}`);
+}
 export function createContext(source, checker, strictNullChecks) {
     const unresolved = [];
     const notes = [];
-    const at = (node) => `${source.fileName}:${source.getLineAndCharacterOfPosition(node.getStart()).line + 1}`;
     return {
         source,
         checker,
@@ -13,12 +31,12 @@ export function createContext(source, checker, strictNullChecks) {
         unresolved,
         notes,
         imports: new Map(),
-        rewritten: { Relation: 0, expr: 0 },
+        rewritten: { expr: 0, Index: 0, Trigger: 0, Filter: 0 },
         report: (node, message) => {
-            unresolved.push(`${at(node)}: ${message}`);
+            unresolved.push(`${locationOf(node)}: ${message}`);
         },
         note: (node, message) => {
-            notes.push(`${at(node)}: ${message}`);
+            notes.push(`${locationOf(node)}: ${message}`);
         },
     };
 }

package/dist/definers.d.ts

@@ -0,0 +1,24 @@
+import ts from 'typescript';
+/** The definers a class was registered with, each with the decorator that registers the same on a decorated class. */
+export declare const CLASS_DEFINERS: {
+    readonly defineEntity: "@Entity";
+    readonly defineField: "@Field";
+    readonly defineId: "@Id";
+    readonly defineRelation: "a relation decorator";
+    readonly defineHook: "a hook decorator";
+    readonly defineIndex: "@Entity's 'indexes'";
+    readonly defineTrigger: "@Entity's 'triggers'";
+    readonly defineFilter: "@Entity's 'filters'";
+};
+export type DefinerName = keyof typeof CLASS_DEFINERS;
+/** A class-form definer's arguments by what each is: `defineX(Entity, key?, options)`, every one after the entity in `rest`. */
+export type DefinerCall = {
+    readonly call: ts.CallExpression;
+    readonly definer: DefinerName;
+    readonly entity: ts.Expression;
+    readonly key: string | undefined;
+    readonly options: ts.Expression | undefined;
+    readonly rest: readonly ts.Expression[];
+};
+/** `call` read as a class-form definer, or nothing where it is another call, the schema form included. */
+export declare function definerCall(call: ts.CallExpression): DefinerCall | undefined;

package/dist/definers.js

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+import { identifierText } from './syntax.js';
+/** The definers a class was registered with, each with the decorator that registers the same on a decorated class. */
+export const CLASS_DEFINERS = {
+    defineEntity: '@Entity',
+    defineField: '@Field',
+    defineId: '@Id',
+    defineRelation: 'a relation decorator',
+    defineHook: 'a hook decorator',
+    defineIndex: "@Entity's 'indexes'",
+    defineTrigger: "@Entity's 'triggers'",
+    defineFilter: "@Entity's 'filters'",
+};
+const isDefinerName = (name) => name !== undefined && Object.hasOwn(CLASS_DEFINERS, name);
+/** The definers naming a member or a filter after the entity, their options after that. */
+const KEYED_DEFINERS = new Set([
+    'defineField',
+    'defineId',
+    'defineRelation',
+    'defineHook',
+    'defineFilter',
+]);
+/** `call` read as a class-form definer, or nothing where it is another call, the schema form included. */
+export function definerCall(call) {
+    const definer = identifierText(call.expression);
+    const [entity, ...rest] = call.arguments;
+    if (!isDefinerName(definer) || !entity || ts.isObjectLiteralExpression(entity)) {
+        return undefined;
+    }
+    const [second, third] = rest;
+    const keyed = KEYED_DEFINERS.has(definer);
+    const key = keyed && second && ts.isStringLiteralLike(second) ? second.text : undefined;
+    return { call, definer, entity, key, options: keyed ? third : second, rest };
+}

package/dist/edits.d.ts

@@ -1,24 +1,56 @@
-import type ts from 'typescript';
+import ts from 'typescript';
+/** A stretch of the original text, which a replacement can keep. */
+export type Span = {
+    readonly start: number;
+    readonly end: number;
+};
+/** A piece of a replacement: text written, or a stretch of the original kept. */
+export type Part = string | Span;
+/** What replaces a range: text, or text with stretches of the original in it, edits inside them included. */
+export type Replacement = string | readonly Part[];
 /** One text replacement in a file. */
 export type Edit = {
     readonly start: number;
     readonly end: number;
+    readonly text: Replacement;
+};
+/** The text of `node` as written, for a replacement to keep. */
+export declare function original(node: ts.Node): Span;
+/**
+ * Applies edits to `source`, which is spliced rather than reprinted: a codemod that reformats everything it
+ * touches buries its own change in the diff. An edit inside a range another replaces is moot, unless that
+ * replacement keeps the stretch it sits in; edits that overlap without one holding the other are a bug.
+ */
+export declare function applyEdits(source: string, edits: readonly Edit[]): string;
+/** A text a pass wrote, with where each of its offsets was in the text the pass read. */
+export type Pass = {
     readonly text: string;
+    readonly sourceOffset: (at: number) => number;
 };
+/** `text` as a pass that changed nothing. */
+export declare const unedited: (text: string) => Pass;
+/** `second` run on what `first` wrote, each offset of its text mapped back to what `first` read. */
+export declare function followed(first: Pass, second: Pass): Pass;
+/** `pass` edited again by the edits `edits` reads off its text, parsed. */
+export declare function reparsedAgain(fileName: string, pass: Pass, edits: (source: ts.SourceFile) => readonly Edit[]): Pass;
 /**
- * Applies edits back to front, so none shifts the offsets of another, and at a shared offset the replacement
- * first, so an insertion there lands before it. Splicing rather than reprinting keeps the rest of the file
- * byte for byte: a codemod that reformats everything it touches buries its own change in the diff.
+ * {@link applyEdits}, with where each offset of the result was in `source`, for a later pass reading the result to
+ * report against the file as written: an offset inside an edit's text maps to where the edit starts.
  */
-export declare function applyEdits(text: string, edits: readonly Edit[]): string;
-export declare function replaced(node: ts.Node, text: string): Edit;
+export declare function editedText(source: string, edits: readonly Edit[]): Pass;
+export declare function replaced(node: ts.Node, text: Replacement): Edit;
 export declare function inserted(node: ts.Node, text: string): Edit;
 export declare function appended(node: ts.Node, text: string): Edit;
+/** `node`'s text with each of `uses`, the nodes inside it, written as `text`. */
+export declare function replacingUses(node: ts.Node, uses: readonly ts.Node[], text: string): string;
+/**
+ * Removes elements of a comma-separated list, at least one of them kept, with the separators that would dangle.
+ * Each removed element takes the text up to the next item; the removed run at the end takes the separator before
+ * it, so the ranges never overlap. `source` is passed because a tree from `ts.parseJsonText` has no `getStart()`.
+ */
+export declare function removeFromList(items: readonly ts.Node[], removed: readonly ts.Node[], source: ts.SourceFile): readonly Edit[];
 /**
- * Removes one element of a comma-separated list with the separator that would dangle: the comma before the
- * last element, the one after any other. `source` is passed because a tree from `ts.parseJsonText` carries
- * no back-reference for `getStart()` to find.
+ * Removes a statement with the blanks before it on its line, the rest of its line and the blank lines after it,
+ * so nothing is left blank behind it.
  */
-export declare function removeFromList(items: readonly ts.Node[], item: ts.Node, source: ts.SourceFile): Edit;
-/** Removes a statement together with the rest of its line, so nothing is left blank behind it. */
 export declare function removeStatement(node: ts.Node): Edit;