eslint-plugin-object-map 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zach Sents
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# eslint-plugin-object-map
+
+Type-aware ESLint rules for object literals that repeatedly map same-name
+properties from a source object.
+
+```ts
+return {
+  createdAt: deployment.createdAt,
+  id: deployment.id,
+  projectId: deployment.projectId,
+  status: deployment.status,
+  workflows: syncedWorkflows,
+}
+```
+
+If TypeScript proves those mapped keys are the complete known shape of
+`deployment`, the plugin recommends a spread. If TypeScript proves `deployment`
+has additional known keys, it recommends a `pick` utility such as Remeda's
+`pick`.
+
+## Rules
+
+- `object-map/prefer-object-spread-for-exact-object-map`
+
+  - Reports repeated same-name property maps when the mapped keys exactly match
+    the source object's known properties.
+  - Recommendation: `{ ...deployment }`.
+
+- `object-map/prefer-pick-for-object-subset-map`
+  - Reports repeated same-name property maps when the mapped keys are a subset
+    of the source object's known properties, or the source has an index
+    signature.
+  - Recommendation: `pick(deployment, ["createdAt", "id", "projectId", "status"])`.
+
+Both rules intentionally skip renamed properties, computed properties,
+already-spread objects, single-property mappings, unions, and unknown-like
+source types.
+
+## Usage
+
+```ts
+// eslint.config.ts
+import objectMap from "eslint-plugin-object-map"
+import parser from "@typescript-eslint/parser"
+
+export default [
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      parser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    plugins: {
+      "object-map": objectMap,
+    },
+    rules: {
+      "object-map/prefer-object-spread-for-exact-object-map": "warn",
+      "object-map/prefer-pick-for-object-subset-map": "warn",
+    },
+  },
+]
+```
+
+## Development
+
+```sh
+bun install
+bun run check
+```
+
+The package uses Bun, Prettier, oxlint with type-aware linting, and zshy for
+build output.

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "prefer-object-spread-for-exact-object-map": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSpread", [({
+            minProperties?: number;
+        } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        "prefer-pick-for-object-subset-map": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferPick", [({
+            minProperties?: number;
+        } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,11 @@
+import preferObjectSpreadForExactObjectMap from "./rules/prefer-object-spread-for-exact-object-map.js";
+import preferPickForObjectSubsetMap from "./rules/prefer-pick-for-object-subset-map.js";
+export default {
+    meta: {
+        name: "object-map",
+    },
+    rules: {
+        "prefer-object-spread-for-exact-object-map": preferObjectSpreadForExactObjectMap,
+        "prefer-pick-for-object-subset-map": preferPickForObjectSubsetMap,
+    },
+};

package/dist/rules/prefer-object-spread-for-exact-object-map.d.ts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+type Options = [
+    {
+        minProperties?: number;
+    }?
+];
+declare const _default: ESLintUtils.RuleModule<"preferSpread", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/prefer-object-spread-for-exact-object-map.js

@@ -0,0 +1,64 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { findSameNamedSourceMappings } from "../shared/exact-property-map.js";
+import { getSourceShape } from "../shared/type-shape.js";
+const createRule = ESLintUtils.RuleCreator((name) => `https://example.invalid/rules/${name}`);
+function hasExactPropertySet(mappedKeys, sourceProperties) {
+    if (mappedKeys.size !== sourceProperties.size)
+        return false;
+    for (const propertyName of sourceProperties) {
+        if (!mappedKeys.has(propertyName))
+            return false;
+    }
+    return true;
+}
+export default createRule({
+    name: "prefer-object-spread-for-exact-object-map",
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Prefer object spread when an object literal remaps all same-named properties from a source object",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    minProperties: {
+                        type: "number",
+                        minimum: 2,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferSpread: "`{{source}}` is remapped by identical property names for all of its known properties. Prefer `{ ...{{source}} }`.",
+        },
+    },
+    defaultOptions: [{ minProperties: 2 }],
+    create(context, [options]) {
+        const services = ESLintUtils.getParserServices(context);
+        const minProperties = options?.minProperties ?? 2;
+        return {
+            ObjectExpression(node) {
+                for (const group of findSameNamedSourceMappings(node, minProperties)) {
+                    const shape = getSourceShape(services, group.sourceNode);
+                    if (shape.kind !== "known" || shape.hasIndexSignature)
+                        continue;
+                    const mappedKeys = new Set(group.mappings.map((mapping) => mapping.keyName));
+                    if (!hasExactPropertySet(mappedKeys, shape.propertyNames))
+                        continue;
+                    const firstMapping = group.mappings.at(0);
+                    if (!firstMapping)
+                        continue;
+                    context.report({
+                        node: firstMapping.node,
+                        messageId: "preferSpread",
+                        data: {
+                            source: group.sourceName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/prefer-pick-for-object-subset-map.d.ts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+type Options = [
+    {
+        minProperties?: number;
+    }?
+];
+declare const _default: ESLintUtils.RuleModule<"preferPick", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/prefer-pick-for-object-subset-map.js

@@ -0,0 +1,72 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { findSameNamedSourceMappings } from "../shared/exact-property-map.js";
+import { getSourceShape } from "../shared/type-shape.js";
+const createRule = ESLintUtils.RuleCreator((name) => `https://example.invalid/rules/${name}`);
+function isStrictSubset(mappedKeys, sourceProperties) {
+    if (mappedKeys.size >= sourceProperties.size)
+        return false;
+    for (const key of mappedKeys) {
+        if (!sourceProperties.has(key))
+            return false;
+    }
+    return true;
+}
+export default createRule({
+    name: "prefer-pick-for-object-subset-map",
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Prefer a pick utility when an object literal remaps a same-named property subset from a source object",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    minProperties: {
+                        type: "number",
+                        minimum: 2,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferPick: "`{{source}}` is remapped by {{count}} identical property names but has other known properties. Prefer `pick({{source}}, [{{keys}}])` or equivalent.",
+        },
+    },
+    defaultOptions: [{ minProperties: 2 }],
+    create(context, [options]) {
+        const services = ESLintUtils.getParserServices(context);
+        const minProperties = options?.minProperties ?? 2;
+        return {
+            ObjectExpression(node) {
+                for (const group of findSameNamedSourceMappings(node, minProperties)) {
+                    const shape = getSourceShape(services, group.sourceNode);
+                    if (shape.kind !== "known")
+                        continue;
+                    const mappedKeys = new Set(group.mappings.map((mapping) => mapping.keyName));
+                    const shouldPick = shape.hasIndexSignature ||
+                        isStrictSubset(mappedKeys, shape.propertyNames);
+                    if (!shouldPick)
+                        continue;
+                    const firstMapping = group.mappings.at(0);
+                    if (!firstMapping)
+                        continue;
+                    const keys = Array.from(mappedKeys)
+                        .toSorted()
+                        .map((key) => `"${key}"`)
+                        .join(", ");
+                    context.report({
+                        node: firstMapping.node,
+                        messageId: "preferPick",
+                        data: {
+                            source: group.sourceName,
+                            count: String(mappedKeys.size),
+                            keys,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/shared/exact-property-map.d.ts

@@ -0,0 +1,11 @@
+import { TSESTree } from "@typescript-eslint/utils";
+export type ExactPropertyMapping = {
+    keyName: string;
+    node: TSESTree.Property;
+};
+export type SourceMappingGroup = {
+    sourceName: string;
+    sourceNode: TSESTree.Identifier;
+    mappings: ExactPropertyMapping[];
+};
+export declare function findSameNamedSourceMappings(objectExpression: TSESTree.ObjectExpression, minProperties: number): SourceMappingGroup[];

package/dist/shared/exact-property-map.js

@@ -0,0 +1,83 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+function getStaticPropertyName(key) {
+    if (key.type === AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === AST_NODE_TYPES.Literal && typeof key.value === "string") {
+        return key.value;
+    }
+    return null;
+}
+function getIdentifierMemberName(member) {
+    if (member.computed || member.property.type !== AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    return member.property.name;
+}
+function getSourceIdentifier(expression) {
+    if (expression.type === AST_NODE_TYPES.Identifier) {
+        return expression;
+    }
+    return null;
+}
+function isSameNamedIdentifierMemberMapping(property) {
+    if (property.computed ||
+        property.kind !== "init" ||
+        property.method ||
+        property.value.type !== AST_NODE_TYPES.MemberExpression) {
+        return null;
+    }
+    const keyName = getStaticPropertyName(property.key);
+    const memberName = getIdentifierMemberName(property.value);
+    const source = getSourceIdentifier(property.value.object);
+    if (!keyName || !memberName || !source || keyName !== memberName) {
+        return null;
+    }
+    return { source, keyName };
+}
+function getSpreadIdentifier(property) {
+    return property.argument.type === AST_NODE_TYPES.Identifier
+        ? property.argument
+        : null;
+}
+export function findSameNamedSourceMappings(objectExpression, minProperties) {
+    const groups = new Map();
+    for (const property of objectExpression.properties) {
+        if (property.type === AST_NODE_TYPES.SpreadElement) {
+            const spreadSource = getSpreadIdentifier(property);
+            if (spreadSource) {
+                const group = groups.get(spreadSource.name);
+                if (group) {
+                    group.hasExistingSpread = true;
+                }
+                else {
+                    groups.set(spreadSource.name, {
+                        sourceName: spreadSource.name,
+                        sourceNode: spreadSource,
+                        mappings: [],
+                        hasExistingSpread: true,
+                    });
+                }
+            }
+            continue;
+        }
+        const mapping = isSameNamedIdentifierMemberMapping(property);
+        if (!mapping)
+            continue;
+        const group = groups.get(mapping.source.name);
+        if (group) {
+            group.mappings.push({ keyName: mapping.keyName, node: property });
+        }
+        else {
+            groups.set(mapping.source.name, {
+                sourceName: mapping.source.name,
+                sourceNode: mapping.source,
+                mappings: [{ keyName: mapping.keyName, node: property }],
+                hasExistingSpread: false,
+            });
+        }
+    }
+    return Array.from(groups.values()).filter((group) => !group.hasExistingSpread &&
+        new Set(group.mappings.map((mapping) => mapping.keyName)).size >=
+            minProperties);
+}

package/dist/shared/type-shape.d.ts

@@ -0,0 +1,10 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { ParserServicesWithTypeInformation } from "@typescript-eslint/utils";
+export type SourceShape = {
+    kind: "known";
+    propertyNames: Set<string>;
+    hasIndexSignature: boolean;
+} | {
+    kind: "unknown";
+};
+export declare function getSourceShape(services: ParserServicesWithTypeInformation, node: TSESTree.Node): SourceShape;

package/dist/shared/type-shape.js

@@ -0,0 +1,40 @@
+import ts from "typescript";
+function isUnknownLikeType(type) {
+    return Boolean(type.flags &
+        (ts.TypeFlags.Any |
+            ts.TypeFlags.Unknown |
+            ts.TypeFlags.Never |
+            ts.TypeFlags.TypeParameter));
+}
+function hasIndexSignature(type, checker) {
+    const apparent = checker.getApparentType(type);
+    return (checker.getIndexInfoOfType(apparent, ts.IndexKind.String) !== undefined ||
+        checker.getIndexInfoOfType(apparent, ts.IndexKind.Number) !== undefined);
+}
+function getStringPropertyName(symbol) {
+    const name = symbol.getName();
+    return name.startsWith("__@") ? null : name;
+}
+export function getSourceShape(services, node) {
+    const type = services.getTypeAtLocation(node);
+    const checker = services.program.getTypeChecker();
+    if (isUnknownLikeType(type) || type.isUnion()) {
+        return { kind: "unknown" };
+    }
+    const apparent = checker.getApparentType(type);
+    if (isUnknownLikeType(apparent) || apparent.getCallSignatures().length > 0) {
+        return { kind: "unknown" };
+    }
+    const propertyNames = new Set(checker
+        .getPropertiesOfType(apparent)
+        .map(getStringPropertyName)
+        .filter((name) => name !== null));
+    if (propertyNames.size === 0) {
+        return { kind: "unknown" };
+    }
+    return {
+        kind: "known",
+        propertyNames,
+        hasIndexSignature: hasIndexSignature(apparent, checker),
+    };
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "eslint-plugin-object-map",
+  "version": "0.1.0",
+  "description": "Type-aware ESLint rules for replacing repeated same-name object property maps with spread or pick.",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "bun@1.3.12",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zachsents/eslint-plugin-object-map.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zachsents/eslint-plugin-object-map/issues"
+  },
+  "homepage": "https://github.com/zachsents/eslint-plugin-object-map#readme",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "typescript-eslint",
+    "type-aware",
+    "object-spread",
+    "pick"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "zshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./rules/*": "./src/rules/*"
+    },
+    "cjs": false,
+    "conditions": {
+      "bun": "src"
+    }
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./rules/*": {
+      "bun": "./src/rules/*",
+      "types": "./dist/rules/*",
+      "default": "./dist/rules/*"
+    }
+  },
+  "scripts": {
+    "typecheck": "command -v tsgo >/dev/null && tsgo --noEmit || tsc --noEmit",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix --fix-suggestions",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "test": "bun test",
+    "build": "zshy",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run test && bun run build",
+    "prepublishOnly": "bun run check"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=20.9"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.62.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/parser": "^8.62.0",
+    "eslint": "^9.39.4",
+    "oxlint": "^1.71.0",
+    "oxlint-tsgolint": "^0.23.0",
+    "prettier": "3.4.2",
+    "prettier-plugin-jsdoc": "^1.8.0",
+    "typescript": "^5.9.3",
+    "zshy": "^0.7.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+import preferObjectSpreadForExactObjectMap from "./rules/prefer-object-spread-for-exact-object-map"
+import preferPickForObjectSubsetMap from "./rules/prefer-pick-for-object-subset-map"
+
+export default {
+  meta: {
+    name: "object-map",
+  },
+  rules: {
+    "prefer-object-spread-for-exact-object-map":
+      preferObjectSpreadForExactObjectMap,
+    "prefer-pick-for-object-subset-map": preferPickForObjectSubsetMap,
+  },
+}

package/src/rules/prefer-object-spread-for-exact-object-map.ts

@@ -0,0 +1,86 @@
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils"
+import { findSameNamedSourceMappings } from "../shared/exact-property-map"
+import { getSourceShape } from "../shared/type-shape"
+
+type Options = [
+  {
+    minProperties?: number
+  }?,
+]
+
+type MessageIds = "preferSpread"
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://example.invalid/rules/${name}`,
+)
+
+function hasExactPropertySet(
+  mappedKeys: Set<string>,
+  sourceProperties: Set<string>,
+): boolean {
+  if (mappedKeys.size !== sourceProperties.size) return false
+
+  for (const propertyName of sourceProperties) {
+    if (!mappedKeys.has(propertyName)) return false
+  }
+
+  return true
+}
+
+export default createRule<Options, MessageIds>({
+  name: "prefer-object-spread-for-exact-object-map",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Prefer object spread when an object literal remaps all same-named properties from a source object",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          minProperties: {
+            type: "number",
+            minimum: 2,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      preferSpread:
+        "`{{source}}` is remapped by identical property names for all of its known properties. Prefer `{ ...{{source}} }`.",
+    },
+  },
+  defaultOptions: [{ minProperties: 2 }],
+  create(context, [options]) {
+    const services = ESLintUtils.getParserServices(context)
+    const minProperties = options?.minProperties ?? 2
+
+    return {
+      ObjectExpression(node: TSESTree.ObjectExpression) {
+        for (const group of findSameNamedSourceMappings(node, minProperties)) {
+          const shape = getSourceShape(services, group.sourceNode)
+          if (shape.kind !== "known" || shape.hasIndexSignature) continue
+
+          const mappedKeys = new Set(
+            group.mappings.map((mapping) => mapping.keyName),
+          )
+
+          if (!hasExactPropertySet(mappedKeys, shape.propertyNames)) continue
+
+          const firstMapping = group.mappings.at(0)
+          if (!firstMapping) continue
+
+          context.report({
+            node: firstMapping.node,
+            messageId: "preferSpread",
+            data: {
+              source: group.sourceName,
+            },
+          })
+        }
+      },
+    }
+  },
+})

package/src/rules/prefer-pick-for-object-subset-map.ts

@@ -0,0 +1,96 @@
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils"
+import { findSameNamedSourceMappings } from "../shared/exact-property-map"
+import { getSourceShape } from "../shared/type-shape"
+
+type Options = [
+  {
+    minProperties?: number
+  }?,
+]
+
+type MessageIds = "preferPick"
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://example.invalid/rules/${name}`,
+)
+
+function isStrictSubset(
+  mappedKeys: Set<string>,
+  sourceProperties: Set<string>,
+): boolean {
+  if (mappedKeys.size >= sourceProperties.size) return false
+
+  for (const key of mappedKeys) {
+    if (!sourceProperties.has(key)) return false
+  }
+
+  return true
+}
+
+export default createRule<Options, MessageIds>({
+  name: "prefer-pick-for-object-subset-map",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Prefer a pick utility when an object literal remaps a same-named property subset from a source object",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          minProperties: {
+            type: "number",
+            minimum: 2,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      preferPick:
+        "`{{source}}` is remapped by {{count}} identical property names but has other known properties. Prefer `pick({{source}}, [{{keys}}])` or equivalent.",
+    },
+  },
+  defaultOptions: [{ minProperties: 2 }],
+  create(context, [options]) {
+    const services = ESLintUtils.getParserServices(context)
+    const minProperties = options?.minProperties ?? 2
+
+    return {
+      ObjectExpression(node: TSESTree.ObjectExpression) {
+        for (const group of findSameNamedSourceMappings(node, minProperties)) {
+          const shape = getSourceShape(services, group.sourceNode)
+          if (shape.kind !== "known") continue
+
+          const mappedKeys = new Set(
+            group.mappings.map((mapping) => mapping.keyName),
+          )
+          const shouldPick =
+            shape.hasIndexSignature ||
+            isStrictSubset(mappedKeys, shape.propertyNames)
+
+          if (!shouldPick) continue
+
+          const firstMapping = group.mappings.at(0)
+          if (!firstMapping) continue
+
+          const keys = Array.from(mappedKeys)
+            .toSorted()
+            .map((key) => `"${key}"`)
+            .join(", ")
+
+          context.report({
+            node: firstMapping.node,
+            messageId: "preferPick",
+            data: {
+              source: group.sourceName,
+              count: String(mappedKeys.size),
+              keys,
+            },
+          })
+        }
+      },
+    }
+  },
+})

package/src/shared/exact-property-map.ts

@@ -0,0 +1,128 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils"
+
+export type ExactPropertyMapping = {
+  keyName: string
+  node: TSESTree.Property
+}
+
+export type SourceMappingGroup = {
+  sourceName: string
+  sourceNode: TSESTree.Identifier
+  mappings: ExactPropertyMapping[]
+}
+
+type GroupState = SourceMappingGroup & {
+  hasExistingSpread: boolean
+}
+
+function getStaticPropertyName(key: TSESTree.Property["key"]): string | null {
+  if (key.type === AST_NODE_TYPES.Identifier) {
+    return key.name
+  }
+
+  if (key.type === AST_NODE_TYPES.Literal && typeof key.value === "string") {
+    return key.value
+  }
+
+  return null
+}
+
+function getIdentifierMemberName(
+  member: TSESTree.MemberExpression,
+): string | null {
+  if (member.computed || member.property.type !== AST_NODE_TYPES.Identifier) {
+    return null
+  }
+
+  return member.property.name
+}
+
+function getSourceIdentifier(
+  expression: TSESTree.Expression,
+): TSESTree.Identifier | null {
+  if (expression.type === AST_NODE_TYPES.Identifier) {
+    return expression
+  }
+
+  return null
+}
+
+function isSameNamedIdentifierMemberMapping(
+  property: TSESTree.Property,
+): { source: TSESTree.Identifier; keyName: string } | null {
+  if (
+    property.computed ||
+    property.kind !== "init" ||
+    property.method ||
+    property.value.type !== AST_NODE_TYPES.MemberExpression
+  ) {
+    return null
+  }
+
+  const keyName = getStaticPropertyName(property.key)
+  const memberName = getIdentifierMemberName(property.value)
+  const source = getSourceIdentifier(property.value.object)
+
+  if (!keyName || !memberName || !source || keyName !== memberName) {
+    return null
+  }
+
+  return { source, keyName }
+}
+
+function getSpreadIdentifier(
+  property: TSESTree.SpreadElement,
+): TSESTree.Identifier | null {
+  return property.argument.type === AST_NODE_TYPES.Identifier
+    ? property.argument
+    : null
+}
+
+export function findSameNamedSourceMappings(
+  objectExpression: TSESTree.ObjectExpression,
+  minProperties: number,
+): SourceMappingGroup[] {
+  const groups = new Map<string, GroupState>()
+
+  for (const property of objectExpression.properties) {
+    if (property.type === AST_NODE_TYPES.SpreadElement) {
+      const spreadSource = getSpreadIdentifier(property)
+      if (spreadSource) {
+        const group = groups.get(spreadSource.name)
+        if (group) {
+          group.hasExistingSpread = true
+        } else {
+          groups.set(spreadSource.name, {
+            sourceName: spreadSource.name,
+            sourceNode: spreadSource,
+            mappings: [],
+            hasExistingSpread: true,
+          })
+        }
+      }
+      continue
+    }
+
+    const mapping = isSameNamedIdentifierMemberMapping(property)
+    if (!mapping) continue
+
+    const group = groups.get(mapping.source.name)
+    if (group) {
+      group.mappings.push({ keyName: mapping.keyName, node: property })
+    } else {
+      groups.set(mapping.source.name, {
+        sourceName: mapping.source.name,
+        sourceNode: mapping.source,
+        mappings: [{ keyName: mapping.keyName, node: property }],
+        hasExistingSpread: false,
+      })
+    }
+  }
+
+  return Array.from(groups.values()).filter(
+    (group) =>
+      !group.hasExistingSpread &&
+      new Set(group.mappings.map((mapping) => mapping.keyName)).size >=
+        minProperties,
+  )
+}

package/src/shared/type-shape.ts

@@ -0,0 +1,71 @@
+import { TSESTree } from "@typescript-eslint/utils"
+import type { ParserServicesWithTypeInformation } from "@typescript-eslint/utils"
+import ts from "typescript"
+
+export type SourceShape =
+  | {
+      kind: "known"
+      propertyNames: Set<string>
+      hasIndexSignature: boolean
+    }
+  | {
+      kind: "unknown"
+    }
+
+function isUnknownLikeType(type: ts.Type): boolean {
+  return Boolean(
+    type.flags &
+      (ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.Never |
+        ts.TypeFlags.TypeParameter),
+  )
+}
+
+function hasIndexSignature(type: ts.Type, checker: ts.TypeChecker): boolean {
+  const apparent = checker.getApparentType(type)
+  return (
+    checker.getIndexInfoOfType(apparent, ts.IndexKind.String) !== undefined ||
+    checker.getIndexInfoOfType(apparent, ts.IndexKind.Number) !== undefined
+  )
+}
+
+function getStringPropertyName(symbol: ts.Symbol): string | null {
+  const name = symbol.getName()
+  return name.startsWith("__@") ? null : name
+}
+
+export function getSourceShape(
+  services: ParserServicesWithTypeInformation,
+  node: TSESTree.Node,
+): SourceShape {
+  const type = services.getTypeAtLocation(node)
+  const checker = services.program.getTypeChecker()
+
+  if (isUnknownLikeType(type) || type.isUnion()) {
+    return { kind: "unknown" }
+  }
+
+  const apparent = checker.getApparentType(type)
+
+  if (isUnknownLikeType(apparent) || apparent.getCallSignatures().length > 0) {
+    return { kind: "unknown" }
+  }
+
+  const propertyNames = new Set(
+    checker
+      .getPropertiesOfType(apparent)
+      .map(getStringPropertyName)
+      .filter((name): name is string => name !== null),
+  )
+
+  if (propertyNames.size === 0) {
+    return { kind: "unknown" }
+  }
+
+  return {
+    kind: "known",
+    propertyNames,
+    hasIndexSignature: hasIndexSignature(apparent, checker),
+  }
+}