test-package.mjs

import assert from "node:assert/strict";
import { spawnSync } from "node:child_process";
import { createHash } from "node:crypto";
import {
  cpSync,
  existsSync,
  mkdirSync,
  mkdtempSync,
  readdirSync,
  readFileSync,
  rmSync,
  writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";

import {
  packageCheckOptions,
  selectedVersions,
} from "./package-check-options.mjs";

const options = packageCheckOptions();
const evidence = [];
const root = resolve(import.meta.dirname, "..");
const output = mkdtempSync(join(tmpdir(), "one-map-tf02-"));
const compiler = join(root, "node_modules/.bin/tsc");
const reactPackage = join(root, "node_modules/react");
const reactTypes = join(root, "node_modules/@types/react");

const backends = [
  "react-map-gl",
  "mapbox-gl",
  "maplibre-gl",
  "@rnmapbox/maps",
  "@maplibre/maplibre-react-native",
  "react-native-teleport",
];

const explicit = [
  "mapbox-web",
  "maplibre-web",
  "mapbox-native",
  "maplibre-native",
];

const cases = [
  { name: "common", conditions: [], entries: [] },
  ...explicit.map((backend) => ({
    name: backend,
    conditions: [],
    entries: [[backend, backend]],
  })),
  ...[[], ["browser"], ["react-native"], ["browser", "react-native"]].map(
    (conditions) => ({
      name: `aliases-${conditions.join("-") || "default"}`,
      conditions,
      entries: ["mapbox", "maplibre"].map((engine) => [
        engine,
        `${engine}-${conditions.includes("react-native") && !conditions.includes("browser") ? "native" : "web"}`,
      ]),
    })
  ),
  ...[
    ["mapbox-web", "maplibre-native"],
    ["maplibre-web", "mapbox-native"],
  ].flatMap((pair, index) =>
    pair.map((backend) => ({
      name: `mixed-${index}-${backend}`,
      conditions: backend.endsWith("native") ? ["react-native"] : ["browser"],
      entries: [[backend, backend]],
    }))
  ),
];

/** Runs a command and includes output only when it fails. */
const run = (command, args, cwd) => {
  const result = spawnSync(command, args, {
    cwd,
    encoding: "utf8",
    env: { ...process.env, NODE_PATH: "" },
  });
  if (result.error) throw result.error;
  assert.equal(
    result.status,
    0,
    `${command} ${args.join(" ")}\n${result.stdout}\n${result.stderr}`
  );
  return result.stdout.trim();
};

/** Resolves a package specifier with Node under the given export conditions. */
const resolvePackage = (consumer, specifier, conditions) => {
  const conditionArgs = conditions.flatMap((name) => ["--conditions", name]);
  const resolved = run(
    "node",
    [
      ...conditionArgs,
      "--input-type=module",
      "-e",
      `console.log(import.meta.resolve(${JSON.stringify(specifier)}))`,
    ],
    consumer
  );

  return fileURLToPath(resolved);
};

const walkDeclarations = (file, seen = new Set()) => {
  const declaration = file.endsWith(".d.ts")
    ? file
    : file.replace(/\.js$/, ".d.ts");

  if (seen.has(declaration) || !existsSync(declaration)) {
    return;
  }

  seen.add(declaration);
  const text = readFileSync(declaration, "utf8");
  const specifiers = [
    ...text.matchAll(/(?:from|import)\s*["']([^"']+)["']/g),
    ...text.matchAll(/import\(["']([^"']+)["']\)/g),
  ].map((match) => match[1]);

  for (const specifier of specifiers) {
    for (const backend of backends) {
      assert.notEqual(specifier, backend, `${declaration} imports ${backend}`);
      assert.notEqual(
        specifier.startsWith(`${backend}/`),
        true,
        `${declaration} imports ${specifier}`
      );
    }

    if (specifier.startsWith(".")) {
      walkDeclarations(join(dirname(declaration), specifier), seen);
    }
  }
};

const main = async () => {
  try {
    let archive = options.archive;
    if (!archive) {
      run(
        "bun",
        ["pm", "pack", "--destination", output, "--ignore-scripts"],
        join(root, "packages/one-map-react")
      );
      const archives = readdirSync(output).filter((name) =>
        name.endsWith(".tgz")
      );
      assert.equal(archives.length, 1);
      archive = join(output, archives[0]);
    }
    const files = run("tar", ["-tzf", archive], output).split("\n");
    assert(files.includes("package/LICENSE"));
    assert(files.includes("package/README.md"));
    assert(files.includes("package/dist/index.d.ts"));
    assert(files.includes("package/dist/index.js"));
    assert(
      files.includes("package/patches/rnmapbox-10.3.7-per-view-events.patch")
    );
    assert(files.includes("package/patches/rnmapbox-10.3.7-tf08.patch"));
    assert(files.includes("package/patches/maplibre-native-11.5.0-tf08.patch"));
    assert(files.includes("package/patches/rnmapbox-10.3.8.patch"));
    for (const file of files) {
      assert.match(
        file,
        /^package\/(?:dist\/.+|patches\/(?:rnmapbox-10\.3\.(?:7-(?:per-view-events|tf08)|8)|maplibre-native-11\.5\.0-tf08)\.patch|package.json|README.md|LICENSE)$/
      );
    }

    for (const scenario of cases) {
      await checkConsumer(archive, scenario);
    }

    console.log(
      `PASS ${cases.length} isolated package selections: common runtime, declaration graph, and export paths.`
    );
    console.log(
      `PACKAGE SHA-256: ${createHash("sha256").update(readFileSync(archive)).digest("hex")}`
    );
    console.log(
      "SCOPE: packed publication, common entry without backend types, and selected-entry file resolution; no wrapper installs, Metro, or native builds."
    );
  } finally {
    rmSync(output, { recursive: true, force: true });
    if (options.evidence)
      writeFileSync(
        options.evidence,
        JSON.stringify({ checks: evidence }, null, 2) + "\n"
      );
  }
};

const checkConsumer = async (archive, scenario) => {
  const consumer = join(output, scenario.name);
  const installed = join(consumer, "node_modules/one-map-react");
  mkdirSync(installed, { recursive: true });
  run(
    "tar",
    ["-xzf", archive, "--strip-components=1", "-C", installed],
    consumer
  );
  cpSync(reactPackage, join(consumer, "node_modules/react"), {
    recursive: true,
  });
  mkdirSync(join(consumer, "node_modules/@types"), { recursive: true });
  cpSync(reactTypes, join(consumer, "node_modules/@types/react"), {
    recursive: true,
  });
  writeFileSync(
    join(consumer, "package.json"),
    '{"private":true,"type":"module"}\n'
  );

  if (Object.keys(options.versions).length) {
    run(
      "bun",
      [
        "add",
        archive,
        ...selectedVersions(
          ["react@19.2.3", "@types/react@19.2.18"],
          options.versions
        ),
      ],
      consumer
    );
  }

  if (scenario.name === "common") {
    walkDeclarations(join(installed, "dist/index.d.ts"));
    writeFileSync(
      join(consumer, "common.mjs"),
      `import * as common from "one-map-react";
console.log(JSON.stringify(Object.keys(common).sort()));
`
    );
    assert.equal(
      run("node", [join(consumer, "common.mjs")], consumer),
      JSON.stringify([
        "Images",
        "Layer",
        "Map",
        "MapSetup",
        "Marker",
        "Source",
        "UserLocation",
        "useMap",
      ])
    );
  }

  for (const [entry, backend] of scenario.entries) {
    const resolved = resolvePackage(
      consumer,
      `one-map-react/${entry}`,
      scenario.conditions
    );
    assert.ok(
      resolved.endsWith(`/dist/${backend}.js`),
      `${scenario.name} ${entry} -> ${resolved}`
    );
  }

  const imports = scenario.entries
    .map(
      ([entry], index) =>
        `import { adapter as selected${index} } from "one-map-react/${entry}";`
    )
    .join("\n");
  const declarations = scenario.entries
    .map(
      ([, backend], index) =>
        `const choice${index}: "${backend}" = selected${index}.backend;`
    )
    .join("\n");

  writeFileSync(
    join(consumer, "selection.tsx"),
    `${imports}
import type { Adapter, Backend, MapRef } from "one-map-react";
import { Map as OneMap, MapSetup, Source, Layer, Marker, useMap } from "one-map-react";
import { forwardRef } from "react";
type Equal<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends (<Value>() => Value extends Right ? 1 : 2) ? true : false;
const exactAdapterKeys: Equal<keyof Adapter, "backend" | "Map" | "Source" | "Layer" | "Images" | "Marker"> = true;
const exactSetupKeys: Equal<keyof import("one-map-react").MapSetupProps, "adapter" | "children"> = true;
const customAdapter: Adapter = {
  backend: "mapbox-web",
  Map: forwardRef<MapRef, import("one-map-react").MapProps>(() => null),
  Source: () => null,
  Layer: () => null,
  Images: () => null,
  Marker: forwardRef<import("one-map-react").MarkerRef, import("one-map-react").MarkerProps>(() => null),
};
const customSetup: import("one-map-react").MapSetupProps = { adapter: customAdapter, children: null };
void customSetup; void exactAdapterKeys; void exactSetupKeys;

${declarations}
declare const commonRef: MapRef;
// @ts-expect-error Source click events are removed.
import type { SourceClickEvent } from "one-map-react";
// @ts-expect-error Common source activation belongs to Map.onClick.
type RemovedCommonSourceCallback = import("one-map-react").SourceProps["onClick"];
// @ts-expect-error Source activation belongs to Map.onClick.
type RemovedSourceCallback = import("one-map-react").GeoJsonSourceProps["onClick"];
// @ts-expect-error Vector source activation belongs to Map.onClick.
type RemovedVectorCallback = import("one-map-react").VectorSourceProps["onClick"];
// @ts-expect-error Supplied location is display only.
type RemovedLocationPress = import("one-map-react").UserLocationProps["onPress"];
// @ts-expect-error Popups are selected wrapper components or application UI.
import { Popup } from "one-map-react";
// @ts-expect-error Common popup props are removed.
import type { PopupProps } from "one-map-react";
declare const adapterContract: Adapter;
// @ts-expect-error Applications own custom control layout.
import { Control } from "one-map-react";
// @ts-expect-error Common custom control props are removed.
import type { ControlProps } from "one-map-react";
// @ts-expect-error Common placement positions are removed.
import type { ControlPosition } from "one-map-react";
// @ts-expect-error Custom adapters no longer supply control composition.
adapterContract.Control;
// @ts-expect-error Location controls belong to the application or selected wrapper.
import { GeolocateControl } from "one-map-react";
// @ts-expect-error Common location control props are removed.
import type { GeolocateControlProps } from "one-map-react";
// @ts-expect-error Custom adapters no longer supply a location control.
adapterContract.GeolocateControl;
// @ts-expect-error Scale belongs to the selected SDK.
import { ScaleControl } from "one-map-react";
// @ts-expect-error Attribution belongs to the selected SDK.
import { AttributionControl } from "one-map-react";
// @ts-expect-error Common scale props, including width and units, are removed.
import type { ScaleControlProps } from "one-map-react";
// @ts-expect-error Common attribution props are removed.
import type { AttributionControlProps } from "one-map-react";
// @ts-expect-error Custom adapters no longer supply scale composition.
adapterContract.ScaleControl;
// @ts-expect-error Custom adapters no longer supply attribution composition.
adapterContract.AttributionControl;
// @ts-expect-error Custom adapters no longer supply popup composition.
adapterContract.Popup;
// @ts-expect-error Applications own camera and browser controls.
import { NavigationControl } from "one-map-react";
// @ts-expect-error The common control props are removed.
import type { NavigationControlProps } from "one-map-react";
// @ts-expect-error Custom adapters no longer supply this control.
adapterContract.NavigationControl;
// @ts-expect-error Applications own camera and browser controls.
import { FullscreenControl } from "one-map-react";
// @ts-expect-error The common control props are removed.
import type { FullscreenControlProps } from "one-map-react";
// @ts-expect-error Custom adapters no longer supply this control.
adapterContract.FullscreenControl;
// @ts-expect-error Offline packs belong to the selected SDK.
import type { OfflinePack } from "one-map-react";
// @ts-expect-error Offline creation options belong to the selected SDK.
import type { OfflinePackOptions } from "one-map-react";
// @ts-expect-error Offline status belongs to the selected SDK.
import type { OfflinePackStatus } from "one-map-react";
// @ts-expect-error No common offline service remains.
import type { OfflineService } from "one-map-react";
// @ts-expect-error Common location services are removed.
import type { MapServices } from "one-map-react";
// @ts-expect-error Common acquisition type is removed.
import type { LocationService } from "one-map-react";
// @ts-expect-error Common acquisition type is removed.
import type { LocationPermission } from "one-map-react";
// @ts-expect-error Common acquisition type is removed.
import type { LocationOptions } from "one-map-react";
// @ts-expect-error Common acquisition type is removed.
import type { LocationAbortSignal } from "one-map-react";

// @ts-expect-error Application acquisition no longer uses a common hook.
import { useMapServices } from "one-map-react";
// @ts-expect-error Custom adapters no longer own app services.
adapterContract.services;
declare const setupProps: import("one-map-react").MapSetupProps;
// @ts-expect-error Setup no longer owns app acquisition.
setupProps.locationProvider;
// @ts-expect-error Common independent image output is removed.
import type { ImageOutput } from "one-map-react";
// @ts-expect-error Common independent image result is removed.
import type { MapImage } from "one-map-react";
// @ts-expect-error Snapshot inputs belong to the selected SDK.
import type { StaticMapImageOptions } from "one-map-react";
// @ts-expect-error No common snapshot service remains.
import type { StaticMapImageService } from "one-map-react";
// @ts-expect-error Capture belongs to the application and selected wrapper.
commonRef.capture({ output: "data-url", scope: "backend" });
// @ts-expect-error Capture-only options are removed from the common package.
import type { CaptureOptions } from "one-map-react";
// @ts-expect-error Capture scope is no longer a common promise.
import type { CaptureScope } from "one-map-react";
// @ts-expect-error Capture-only results are removed from the common package.
import type { MapCapture } from "one-map-react";
// @ts-expect-error Wrapper access belongs only to selected web refs.
commonRef.getWrapperMap();
// @ts-expect-error Common hooks retain the portable ref contract.
useMap().getWrapperMap();
const applicationChoice = (adapter: Adapter): Backend => adapter.backend;
void Marker; void useMap;
void MapSetup;
void Source;
void Layer;
void applicationChoice;
const viewState = {
  longitude: -122.34,
  latitude: 47.61,
  zoom: 11,
  bearing: 0,
  pitch: 0,
};
const style = { version: 8 as const, sources: {}, layers: [] };
// @ts-expect-error Drawing-buffer configuration is a selected wrapper option.
void <OneMap mapStyle={style} initialViewState={viewState} captureEnabled />;
void (
  <OneMap mapStyle={style} initialViewState={viewState} terrain={{ source: "dem", exaggeration: 0 }} projection="mercator" light={{ intensity: 0 }} />
);
void (
  <OneMap
    mapStyle={style}
    initialViewState={viewState}
    // @ts-expect-error Invalid map props must not type-check.
    definitelyNotAMapProp
  />
);
// @ts-expect-error An arbitrary backend must not type-check.
const invalid: Adapter = { backend: "automatic" };
`
  );
  writeFileSync(
    join(consumer, "tsconfig.json"),
    JSON.stringify({
      compilerOptions: {
        target: "ES2022",
        module: "NodeNext",
        moduleResolution: "NodeNext",
        jsx: "react-jsx",
        strict: true,
        noEmit: true,
        skipLibCheck: true,
        types: [],
        lib: ["ES2022"],
        customConditions: scenario.conditions,
      },
      files: ["selection.tsx"],
    })
  );
  run(compiler, ["-p", "tsconfig.json"], consumer);

  const installedPackages = readdirSync(join(consumer, "node_modules"));
  assert.deepEqual(installedPackages.sort(), [
    "@types",
    ...(Object.keys(options.versions).length ? ["csstype"] : []),
    "one-map-react",
    "react",
  ]);
  evidence.push({
    scenario: scenario.name,
    archiveSha256: createHash("sha256")
      .update(readFileSync(archive))
      .digest("hex"),
    react: JSON.parse(
      readFileSync(join(consumer, "node_modules/react/package.json"), "utf8")
    ).version,
    reactTypes: JSON.parse(
      readFileSync(
        join(consumer, "node_modules/@types/react/package.json"),
        "utf8"
      )
    ).version,
    lockfileSha256: existsSync(join(consumer, "bun.lock"))
      ? createHash("sha256")
          .update(readFileSync(join(consumer, "bun.lock")))
          .digest("hex")
      : null,
    status: "passed",
    scope:
      "common/root host and peer-free selected declaration resolution only; selected/native peer compatibility is checked by test-peers",
  });
  rmSync(consumer, { recursive: true, force: true });
};

await main();