locate-path 6.0.0

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/locate-path@6.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/locate-path@6.0.0

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:53c860531c53927fb3fe8f12dfd3998009f6f42c7ad56463eedbe39ef966ded9","contract":["locatePath resolves to the first existing file in candidate paths","locatePath resolves to undefined when no candidate paths exist","locatePath supports type: directory to locate existing directories only","locatePath.sync returns the first existing file synchronously","locatePath.sync supports type: directory to locate directories synchronously","locatePath.sync returns undefined when no candidate paths exist","locatePath throws error when invalid type is specified","findFirstFile, findFirstDirectory, findFirstFileSync, and findFirstDirectorySync helper functions locate files and directories"],"goal":"verify pkg:npm/locate-path@6.0.0","kind":"HOW","packages":["pkg:npm/locate-path@6.0.0"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/locate-path@6.0.0"],"schemaVersion":1,"subject":"pkg:npm/locate-path@6.0.0","verifierAdapter":"node-typescript@1"}

const locatePath = require('locate-path');

async function findFirstFile(paths, options) {
  return await locatePath(paths, { ...options, type: 'file' });
}

async function findFirstDirectory(paths, options) {
  return await locatePath(paths, { ...options, type: 'directory' });
}

function findFirstFileSync(paths, options) {
  return locatePath.sync(paths, { ...options, type: 'file' });
}

function findFirstDirectorySync(paths, options) {
  return locatePath.sync(paths, { ...options, type: 'directory' });
}

module.exports = {
  findFirstFile,
  findFirstDirectory,
  findFirstFileSync,
  findFirstDirectorySync,
  locatePath
};

{
  "name": "sample-locate-path",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-locate-path",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "locate-path": "6.0.0"
      }
    },
    "node_modules/locate-path": {
      "version": "6.0.0",
      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
      "license": "MIT",
      "dependencies": {
        "p-locate": "^5.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/p-limit": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
      "license": "MIT",
      "dependencies": {
        "yocto-queue": "^0.1.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/p-locate": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
      "license": "MIT",
      "dependencies": {
        "p-limit": "^3.0.2"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/yocto-queue": {
      "version": "0.1.0",
      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    }
  }
}

{
  "name": "sample-locate-path",
  "version": "1.0.0",
  "description": "Minimal sample verifying pkg:npm/locate-path@6.0.0",
  "main": "index.js",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "license": "MIT-0",
  "dependencies": {
    "locate-path": "6.0.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/locate-path@6.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/locate-path@6.0.0"
  ]
}

import assert from 'assert';
import path from 'path';
import os from 'os';
import fs from 'fs';
import locatePath from 'locate-path';
import { createRequire } from 'module';

const require = createRequire(import.meta.url);
const {
  findFirstFile,
  findFirstDirectory,
  findFirstFileSync,
  findFirstDirectorySync
} = require('../index.js');

async function runContract() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'locate-path-contract-'));
  try {
    const fileA = path.join(tmpDir, 'alpha.txt');
    const subDir = path.join(tmpDir, 'subdir');
    const fileInSub = path.join(subDir, 'inner.txt');

    fs.mkdirSync(subDir);
    fs.writeFileSync(fileA, 'hello alpha');
    fs.writeFileSync(fileInSub, 'hello inner');

    // 1. locatePath resolves to the first existing file in candidate paths
    const foundAsync = await locatePath(['nonexistent.txt', 'alpha.txt', 'other.txt'], { cwd: tmpDir });
    assert.strictEqual(foundAsync, 'alpha.txt', 'locatePath should find alpha.txt');

    // 2. locatePath resolves to undefined when no candidate paths exist
    const notFoundAsync = await locatePath(['missing1.txt', 'missing2.txt'], { cwd: tmpDir });
    assert.strictEqual(notFoundAsync, undefined, 'locatePath should return undefined for missing files');

    // 3. locatePath supports type: "directory" to locate existing directories only
    const foundDirAsync = await locatePath(['alpha.txt', 'subdir'], { cwd: tmpDir, type: 'directory' });
    assert.strictEqual(foundDirAsync, 'subdir', 'locatePath with type: directory should skip files and find subdir');

    // 4. locatePath.sync returns the first existing file synchronously
    const foundSync = locatePath.sync(['nonexistent.txt', 'alpha.txt'], { cwd: tmpDir });
    assert.strictEqual(foundSync, 'alpha.txt', 'locatePath.sync should find alpha.txt');

    // 5. locatePath.sync supports type: "directory" to locate directories synchronously
    const foundDirSync = locatePath.sync(['alpha.txt', 'subdir'], { cwd: tmpDir, type: 'directory' });
    assert.strictEqual(foundDirSync, 'subdir', 'locatePath.sync with type: directory should find subdir');

    // 6. locatePath.sync returns undefined when no candidate paths exist
    const notFoundSync = locatePath.sync(['missing1.txt', 'missing2.txt'], { cwd: tmpDir });
    assert.strictEqual(notFoundSync, undefined, 'locatePath.sync should return undefined for missing paths');

    // 7. locatePath rejects or throws on invalid type
    await assert.rejects(
      async () => {
        await locatePath(['alpha.txt'], { cwd: tmpDir, type: 'invalid_type' });
      },
      /Invalid type specified/,
      'locatePath should reject with invalid type'
    );

    assert.throws(
      () => {
        locatePath.sync(['alpha.txt'], { cwd: tmpDir, type: 'invalid_type' });
      },
      /Invalid type specified/,
      'locatePath.sync should throw with invalid type'
    );

    // 8. verify helper functions in index.js
    const helperFile = await findFirstFile(['missing.txt', 'alpha.txt'], { cwd: tmpDir });
    assert.strictEqual(helperFile, 'alpha.txt');

    const helperDir = await findFirstDirectory(['alpha.txt', 'subdir'], { cwd: tmpDir });
    assert.strictEqual(helperDir, 'subdir');

    const helperFileSync = findFirstFileSync(['missing.txt', 'alpha.txt'], { cwd: tmpDir });
    assert.strictEqual(helperFileSync, 'alpha.txt');

    const helperDirSync = findFirstDirectorySync(['alpha.txt', 'subdir'], { cwd: tmpDir });
    assert.strictEqual(helperDirSync, 'subdir');

    console.log('Contract tests passed successfully.');
  } finally {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  }
}

runContract().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});