@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/contextual-uses.js

@@ -0,0 +1,240 @@
+/**
+ * The uses contextual types make of the target's members, which no name node resolves to.
+ * An object-literal property writes the member of its name on each constituent of the
+ * literal's contextual type that declares one. A value reaching a position typed by another
+ * object type reads each of its members that type declares, through array elements and
+ * function parameters and results too; a class instance there is the
+ * interface-satisfaction class's evidence instead.
+ */
+import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { SignatureKind } from "@typescript/native/unstable/sync";
+import { isAnswered } from "./query.js";
+/** The member kinds a contextual type writes and reads: data members and the members of object types. */
+const MEMBER_KINDS = new Set(["type-member", "class-member"]);
+/** The name one literal property is written under, where the name is literal text. */
+function propertyName(property) {
+    if (!isPropertyAssignment(property) &&
+        !isShorthandPropertyAssignment(property) &&
+        !isMethodDeclaration(property) &&
+        !isGetAccessorDeclaration(property) &&
+        !isSetAccessorDeclaration(property)) {
+        return undefined;
+    }
+    const name = property.name;
+    if (isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)) {
+        return { node: name, text: name.text };
+    }
+    if (isComputedPropertyName(name)) {
+        const key = name.expression;
+        if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
+            return { node: name, text: key.text };
+        }
+    }
+    return undefined;
+}
+/** How many element and signature steps the structural walk takes below a value's own type. */
+const MAX_DEPTH = 3;
+/**
+ * The contextual uses of one project's literals and values, asked in batches: one
+ * contextual type per literal and per value whose type carries a member of the target,
+ * one type per value, and each distinct type's properties once.
+ */
+export function contextualUses(project, held, chains, literals, flows, cap, properties) {
+    const queries = project.queries;
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    let batches = 0;
+    let lookups = 0;
+    const batchesOf = (count) => Math.ceil(count / cap);
+    const parts = new Map();
+    /** The object types one type is: itself, or its constituents at any depth. */
+    const partsOf = (type) => {
+        const known = parts.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            lookups += 1;
+            const constituents = queries.constituents(type);
+            found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+        }
+        else if (type.isObjectType()) {
+            found = [type];
+        }
+        parts.set(type.id, found);
+        return found;
+    };
+    const tables = new Map();
+    /** The members one object type has, by name. */
+    const membersOf = (type) => {
+        const known = tables.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const table = new Map();
+        const read = properties.of(type);
+        lookups += read.asked ? 1 : 0;
+        for (const property of isAnswered(read.properties) ? read.properties : []) {
+            table.set(property.name, {
+                ids: chains
+                    .declarationsOf(property)
+                    .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+                handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
+            });
+        }
+        tables.set(type.id, table);
+        return table;
+    };
+    const writes = [];
+    batches += batchesOf(literals.length);
+    const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
+    literals.forEach(({ literal, from }, index) => {
+        const context = contexts[index];
+        if (context === undefined || !isAnswered(context)) {
+            return;
+        }
+        const tablesOf = partsOf(context).map(membersOf);
+        for (const property of literal.properties) {
+            const name = propertyName(property);
+            if (name === undefined) {
+                continue;
+            }
+            const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+            if (ids.length > 0) {
+                writes.push({ at: name.node, from, ids });
+            }
+        }
+    });
+    const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
+    batches += batchesOf(carried.length);
+    const types = queries.typesAt(carried.map((flow) => flow.value), cap);
+    /** The members a position may read structurally: those of object types, not of classes. */
+    const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
+    const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
+    const elements = new Map();
+    /** The element type of an array type, read once per type. */
+    const elementOf = (type) => {
+        if (elements.has(type.id)) {
+            return elements.get(type.id);
+        }
+        lookups += 1;
+        const isArray = queries.isArray(type);
+        let element;
+        if (isAnswered(isArray) && isArray) {
+            lookups += 1;
+            const held = queries.typeArguments(type);
+            element = isAnswered(held) ? held[0] : undefined;
+        }
+        elements.set(type.id, element);
+        return element;
+    };
+    const calls = new Map();
+    /** The parameter and return types of a type's one call signature, read once per type. */
+    const callOf = (type) => {
+        if (calls.has(type.id)) {
+            return calls.get(type.id);
+        }
+        lookups += 1;
+        const signatures = queries.signaturesOf(type, SignatureKind.Call);
+        let called;
+        const [signature, ...more] = isAnswered(signatures) ? signatures : [];
+        if (signature !== undefined && more.length === 0) {
+            const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
+            const result = queries.returnTypeOf(signature);
+            lookups += parameters.length + 1;
+            called = {
+                parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
+                result: isAnswered(result) ? result : undefined,
+            };
+        }
+        calls.set(type.id, called);
+        return called;
+    };
+    /**
+     * Each object type a value of `source` is checked as against the object types of
+     * `target`: the value's own, and through array elements and through a function's
+     * parameters, checked the other way, and its result. A source that is one of the
+     * target's own object types matches it as it stands.
+     */
+    const compared = (source, target, depth, into, seen) => {
+        const key = `${String(source?.id)}>${String(target?.id)}`;
+        if (source === undefined || target === undefined || source.id === target.id) {
+            return;
+        }
+        if (depth > MAX_DEPTH || seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        const targets = partsOf(target);
+        const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
+        for (const one of sources) {
+            if (carries(one)) {
+                into.push({ source: one, targets });
+            }
+            const element = elementOf(one);
+            const called = element === undefined ? callOf(one) : undefined;
+            for (const part of targets) {
+                if (element !== undefined) {
+                    compared(element, elementOf(part), depth + 1, into, seen);
+                    continue;
+                }
+                const other = called === undefined ? undefined : callOf(part);
+                if (called === undefined || other === undefined) {
+                    continue;
+                }
+                other.parameters.forEach((parameter, index) => {
+                    compared(parameter, called.parameters[index], depth + 1, into, seen);
+                });
+                compared(called.result, other.result, depth + 1, into, seen);
+            }
+        }
+    };
+    /** Whether a value of one type may carry a member a position reads, at any depth the walk takes. */
+    const mayCarry = (type, depth) => depth <= MAX_DEPTH &&
+        partsOf(type).some((part) => {
+            if (carries(part)) {
+                return true;
+            }
+            const element = elementOf(part);
+            if (element !== undefined) {
+                return mayCarry(element, depth + 1);
+            }
+            return callOf(part) !== undefined;
+        });
+    const sourced = carried.flatMap((flow, index) => {
+        const type = types[index];
+        return type === undefined || !isAnswered(type) || !mayCarry(type, 0) ? [] : [{ flow, type }];
+    });
+    batches += batchesOf(sourced.length);
+    const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
+    const reads = [];
+    sourced.forEach(({ flow, type }, index) => {
+        const position = positions[index];
+        if (position === undefined || !isAnswered(position)) {
+            return;
+        }
+        const checked = [];
+        compared(type, position, 0, checked, new Set());
+        const ids = new Set();
+        for (const { source, targets } of checked) {
+            const tables = targets.map(membersOf);
+            for (const [name, member] of membersOf(source)) {
+                const read = tables.some((table) => {
+                    const declared = table.get(name);
+                    return (declared !== undefined &&
+                        declared.handles.size > 0 &&
+                        ![...declared.handles].some((handle) => member.handles.has(handle)));
+                });
+                if (read) {
+                    for (const id of readable(member)) {
+                        ids.add(id);
+                    }
+                }
+            }
+        }
+        if (ids.size > 0) {
+            reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
+        }
+    });
+    return { writes, reads, batches, lookups };
+}

package/dist/src/convention-rows.js

@@ -0,0 +1,389 @@
+/**
+ * The convention rows this analyzer carries: the file-system conventions of one
+ * framework or tool each, as data. Nothing outside the table names a framework.
+ *
+ * A row's globs are matched against the directory of the manifest that declares its
+ * enabling package. A glob may hold `<id>` placeholders, each standing for the
+ * directory one of the row's moves resolves to.
+ */
+const SCRIPT = "{js,jsx,ts,tsx}";
+const MODULE = "{js,mjs,ts,mts}";
+const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
+const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
+const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
+/** SvelteKit's entries other than its parameter matchers. */
+const SVELTEKIT_ENTRIES = [
+    `<routes>/**/${SVELTEKIT_ROUTE_FILES}.{js,ts,svelte}`,
+    `<routes>/**/${SVELTEKIT_ROUTE_FILES}@*.{js,ts,svelte}`,
+    "<hooksClient>{,/index}.{js,ts}",
+    "<hooksServer>{,/index}.{js,ts}",
+    "<hooksUniversal>{,/index}.{js,ts}",
+    "<serviceWorker>{,/index}.{js,ts}",
+    "<src>/instrumentation.server.{js,ts}",
+];
+const SVELTEKIT_PLUGIN = { module: "@sveltejs/kit/vite", export: "sveltekit" };
+/** The entries React Router's framework mode and Remix share below their app directory. */
+const APP_DIRECTORY_ENTRIES = [
+    `<app>/root.${SCRIPT}`,
+    `<app>/routes.${MODULE}`,
+    `<app>/entry.{client,server}.${SCRIPT}`,
+    `<app>/routes/**/*.${SCRIPT}`,
+];
+const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart" };
+const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
+/** Every row, ordered by name and then by range. */
+export const CONVENTION_ROWS = [
+    {
+        name: "astro",
+        package: "astro",
+        range: ">=5.0.0 <8.0.0",
+        entries: [
+            "<src>/pages/**/*.{astro,js,ts}",
+            "<src>/middleware{,/index}.{js,ts}",
+            "<src>/actions/index.{js,ts}",
+            `<src>/{content,live}.config.${MODULE}`,
+            `<src>/content/config.${MODULE}`,
+        ],
+        excludes: ["<src>/pages/**/_*", "<src>/pages/**/_*/**"],
+        generated: [".astro"],
+        moves: [
+            {
+                id: "src",
+                defaults: ["src"],
+                readings: [{ property: "srcDir", files: [`astro.config.${ANY_MODULE}`] }],
+            },
+        ],
+    },
+    {
+        name: "eslint",
+        package: "eslint",
+        range: ">=10.0.0 <11.0.0",
+        entries: [`**/eslint.config.${ANY_MODULE}`],
+        moves: [],
+    },
+    {
+        name: "expo-router",
+        package: "expo-router",
+        range: ">=3.0.0 <58.0.0",
+        entries: [`{,src/}app/**/*.${SCRIPT}`],
+        moves: [],
+    },
+    {
+        name: "next",
+        package: "next",
+        range: ">=13.4.0 <17.0.0",
+        generated: [".next"],
+        entries: [
+            `{,src/}app/**/{layout,page,loading,not-found,error,route,template,default,forbidden,unauthorized}.${SCRIPT}`,
+            `{,src/}app/global-{error,not-found}.${SCRIPT}`,
+            `{,src/}app/**/{icon,apple-icon,opengraph-image,twitter-image}.${SCRIPT}`,
+            "{,src/}app/**/sitemap.{js,ts}",
+            "{,src/}app/{robots,manifest}.{js,ts}",
+            "{,src/}app/(*)/{robots,manifest}.{js,ts}",
+            `{,src/}pages/**/*.${SCRIPT}`,
+            `{,src/}{proxy,middleware,instrumentation,instrumentation-client,mdx-components}.${SCRIPT}`,
+        ],
+        moves: [],
+    },
+    {
+        name: "nuxt",
+        package: "nuxt",
+        range: ">=3.0.0 <5.0.0",
+        generated: [".nuxt"],
+        entries: [
+            "<srcDir>/{app,error}.{vue,jsx,tsx}",
+            `<srcDir>/app.config.${MODULE}`,
+            "<srcDir>/router.options.{js,ts}",
+            "<pages>/**/*.{vue,js,jsx,ts,tsx}",
+            "<layouts>/**/*.{vue,jsx,tsx}",
+            "<middleware>/**/*.{js,ts}",
+            "<plugins>/**/*.{js,ts}",
+            "<modules>/*.{js,ts}",
+            "<modules>/*/index.{js,ts}",
+            `<serverDir>/{api,routes,middleware,plugins,tasks}/**/*.${MODULE}`,
+            `layers/*/nuxt.config.${MODULE}`,
+        ],
+        moves: [
+            {
+                id: "srcDir",
+                defaults: ["app", "."],
+                readings: [{ property: "srcDir", files: NUXT_CONFIG }],
+            },
+            {
+                id: "pages",
+                base: "<srcDir>",
+                defaults: ["pages"],
+                readings: [{ property: "dir.pages", files: NUXT_CONFIG }],
+            },
+            {
+                id: "layouts",
+                base: "<srcDir>",
+                defaults: ["layouts"],
+                readings: [{ property: "dir.layouts", files: NUXT_CONFIG }],
+            },
+            {
+                id: "middleware",
+                base: "<srcDir>",
+                defaults: ["middleware"],
+                readings: [{ property: "dir.middleware", files: NUXT_CONFIG }],
+            },
+            {
+                id: "plugins",
+                base: "<srcDir>",
+                defaults: ["plugins"],
+                readings: [{ property: "dir.plugins", files: NUXT_CONFIG }],
+            },
+            {
+                id: "modules",
+                defaults: ["modules"],
+                readings: [{ property: "dir.modules", files: NUXT_CONFIG }],
+            },
+            {
+                id: "serverDir",
+                defaults: ["server"],
+                readings: [{ property: "serverDir", files: NUXT_CONFIG }],
+            },
+        ],
+    },
+    {
+        name: "qwik-city",
+        package: "@builder.io/qwik-city",
+        range: ">=1.0.0 <2.0.0",
+        entries: [
+            "<srcDir>/root.{jsx,tsx}",
+            `<srcDir>/entry.*.${SCRIPT}`,
+            `<routesDir>/**/*.${SCRIPT}`,
+        ],
+        moves: [
+            {
+                id: "srcDir",
+                defaults: ["src"],
+                readings: [
+                    {
+                        property: "srcDir",
+                        files: [VITE_CONFIG],
+                        call: { module: "@builder.io/qwik/optimizer", export: "qwikVite" },
+                    },
+                ],
+            },
+            {
+                id: "routesDir",
+                defaults: ["<srcDir>/routes"],
+                readings: [
+                    {
+                        property: "routesDir",
+                        files: [VITE_CONFIG],
+                        call: { module: "@builder.io/qwik-city/vite", export: "qwikCity" },
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        name: "react-router",
+        package: "@react-router/dev",
+        range: ">=7.0.0 <9.0.0",
+        entries: APP_DIRECTORY_ENTRIES,
+        generated: [".react-router"],
+        moves: [
+            {
+                id: "app",
+                defaults: ["app"],
+                readings: [{ property: "appDirectory", files: [`react-router.config.${MODULE}`] }],
+            },
+        ],
+    },
+    {
+        name: "remix",
+        package: "@remix-run/dev",
+        range: ">=2.0.0 <3.0.0",
+        entries: APP_DIRECTORY_ENTRIES,
+        moves: [
+            {
+                id: "app",
+                defaults: ["app"],
+                readings: [
+                    { property: "appDirectory", files: ["remix.config.{js,cjs,mjs}"] },
+                    {
+                        property: "appDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@remix-run/dev", export: "vitePlugin" },
+                    },
+                    {
+                        property: "appDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@remix-run/dev", export: "unstable_vitePlugin" },
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        name: "solidstart",
+        package: "@solidjs/start",
+        range: ">=1.0.0 <3.0.0",
+        entries: [
+            `<appRoot>/app.${SCRIPT}`,
+            `<appRoot>/entry-{client,server}.${SCRIPT}`,
+            "<appRoot>/middleware{,/index}.{js,ts}",
+            `<routeDir>/**/*.${SCRIPT}`,
+        ],
+        moves: [
+            {
+                id: "appRoot",
+                defaults: ["src"],
+                readings: [
+                    { property: "appRoot", files: [`app.config.${MODULE}`] },
+                    { property: "appRoot", files: [VITE_CONFIG], call: SOLIDSTART_PLUGIN },
+                ],
+            },
+            {
+                id: "routeDir",
+                base: "<appRoot>",
+                defaults: ["routes"],
+                readings: [
+                    { property: "routeDir", files: [`app.config.${MODULE}`] },
+                    { property: "routeDir", files: [VITE_CONFIG], call: SOLIDSTART_PLUGIN },
+                ],
+            },
+        ],
+    },
+    {
+        name: "storybook",
+        package: "storybook",
+        range: ">=7.0.0 <11.0.0",
+        entries: [
+            `.storybook/{main,preview,manager,test-runner,vitest.setup}.{js,jsx,mjs,cjs,ts,tsx,mts,cts}`,
+            "**/*.stories.{js,jsx,mjs,ts,tsx,mts,svelte,vue}",
+        ],
+        moves: [],
+    },
+    {
+        name: "sveltekit",
+        package: "@sveltejs/kit",
+        range: ">=2.0.0 <3.0.0",
+        entries: [...SVELTEKIT_ENTRIES, "<params>/*.{js,ts}"],
+        generated: [".svelte-kit"],
+        moves: [
+            {
+                id: "src",
+                defaults: ["src"],
+                readings: [
+                    { property: "kit.files.src", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.src", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "routes",
+                defaults: ["<src>/routes"],
+                readings: [
+                    { property: "kit.files.routes", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.routes", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "params",
+                defaults: ["<src>/params"],
+                readings: [
+                    { property: "kit.files.params", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.params", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "hooksClient",
+                defaults: ["<src>/hooks.client"],
+                readings: [
+                    { property: "kit.files.hooks.client", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.hooks.client", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "hooksServer",
+                defaults: ["<src>/hooks.server"],
+                readings: [
+                    { property: "kit.files.hooks.server", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.hooks.server", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "hooksUniversal",
+                defaults: ["<src>/hooks"],
+                readings: [
+                    { property: "kit.files.hooks.universal", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.hooks.universal", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "serviceWorker",
+                defaults: ["<src>/service-worker"],
+                readings: [
+                    { property: "kit.files.serviceWorker", files: ["svelte.config.{js,mjs,ts}"] },
+                    { property: "files.serviceWorker", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+        ],
+    },
+    {
+        name: "sveltekit",
+        package: "@sveltejs/kit",
+        range: ">=3.0.0 <4.0.0",
+        entries: [...SVELTEKIT_ENTRIES, "<params>.{js,ts}"],
+        generated: [".svelte-kit"],
+        moves: [
+            {
+                id: "src",
+                defaults: ["src"],
+                readings: [{ property: "files.src", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN }],
+            },
+            {
+                id: "routes",
+                defaults: ["<src>/routes"],
+                readings: [{ property: "files.routes", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN }],
+            },
+            {
+                id: "params",
+                defaults: ["<src>/params"],
+                readings: [{ property: "files.params", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN }],
+            },
+            {
+                id: "hooksClient",
+                defaults: ["<src>/hooks.client"],
+                readings: [
+                    { property: "files.hooks.client", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "hooksServer",
+                defaults: ["<src>/hooks.server"],
+                readings: [
+                    { property: "files.hooks.server", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "hooksUniversal",
+                defaults: ["<src>/hooks"],
+                readings: [
+                    { property: "files.hooks.universal", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+            {
+                id: "serviceWorker",
+                defaults: ["<src>/service-worker"],
+                readings: [
+                    { property: "files.serviceWorker", files: [VITE_CONFIG], call: SVELTEKIT_PLUGIN },
+                ],
+            },
+        ],
+    },
+    {
+        name: "vitest",
+        package: "vitest",
+        range: ">=3.2.0 <6.0.0",
+        entries: [
+            `**/{vitest,vite}.config.${ANY_MODULE}`,
+            `**/{vitest,vite}.config.*.${ANY_MODULE}`,
+            `**/{vitest,vite}.*.config.${ANY_MODULE}`,
+        ],
+        moves: [],
+    },
+];