escalade 3.2.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/escalade@3.2.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/escalade@3.2.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:c56ccae4f012c3eae17ea033d839a160616599f2bef1eeeafbc1b79d938b8959","contract":["escalade asynchronously ascends parent directories and resolves to the matching file path when callback returns a filename","escalade/sync synchronously ascends parent directories and returns the matching file path when callback returns a filename","escalade resolves to undefined when no match is found up to the root directory"],"goal":"verify pkg:npm/escalade@3.2.0","kind":"HOW","packages":["pkg:npm/escalade@3.2.0"],"schemaVersion":1},"contractCommand":["node","test/contract.cjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/escalade@3.2.0"],"schemaVersion":1,"subject":"pkg:npm/escalade@3.2.0","verifierAdapter":"node-typescript@1"}

'use strict';

const escalade = require('escalade');
const escaladeSync = require('escalade/sync');

async function findFileAsync(startDir, targetFileName) {
  return await escalade(startDir, (dir, names) => {
    if (names.includes(targetFileName)) {
      return targetFileName;
    }
  });
}

function findFileSync(startDir, targetFileName) {
  return escaladeSync(startDir, (dir, names) => {
    if (names.includes(targetFileName)) {
      return targetFileName;
    }
  });
}

module.exports = {
  findFileAsync,
  findFileSync,
  escalade,
  escaladeSync
};

{
  "name": "sample-escalade",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-escalade",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "escalade": "3.2.0"
      }
    },
    "node_modules/escalade": {
      "version": "3.2.0",
      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    }
  }
}

{
  "name": "sample-escalade",
  "version": "1.0.0",
  "private": true,
  "description": "verify pkg:npm/escalade@3.2.0",
  "main": "index.js",
  "scripts": {
    "test": "node test/contract.cjs"
  },
  "dependencies": {
    "escalade": "3.2.0"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/escalade@3.2.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/escalade@3.2.0"
  ]
}

'use strict';

const assert = require('assert');
const fs = require('fs');
const path = require('path');
const os = require('os');
const escalade = require('escalade');
const escaladeSync = require('escalade/sync');
const { findFileAsync, findFileSync } = require('../index.js');

async function run() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'escalade-contract-test-'));
  const subDir = path.join(tmpDir, 'a', 'b', 'c');
  const targetFile = path.join(tmpDir, 'target.config.json');

  try {
    fs.mkdirSync(subDir, { recursive: true });
    fs.writeFileSync(targetFile, '{"key": "value"}', 'utf8');

    // 1. Asynchronous escalade lookup
    const asyncFound = await escalade(subDir, (dir, names) => {
      if (names.includes('target.config.json')) {
        return 'target.config.json';
      }
    });
    assert.strictEqual(asyncFound, targetFile, 'escalade must resolve to the full path of the target file');

    // 2. Synchronous escalade/sync lookup
    const syncFound = escaladeSync(subDir, (dir, names) => {
      if (names.includes('target.config.json')) {
        return 'target.config.json';
      }
    });
    assert.strictEqual(syncFound, targetFile, 'escaladeSync must return the full path of the target file');

    // 3. Helper functions from index.js
    const helperAsyncFound = await findFileAsync(subDir, 'target.config.json');
    assert.strictEqual(helperAsyncFound, targetFile, 'findFileAsync must return the full path');

    const helperSyncFound = findFileSync(subDir, 'target.config.json');
    assert.strictEqual(helperSyncFound, targetFile, 'findFileSync must return the full path');

    // 4. Missing file returns undefined / resolves to undefined
    const asyncNotFound = await escalade(subDir, (dir, names) => {
      if (names.includes('non-existent-file.xyz')) {
        return 'non-existent-file.xyz';
      }
    });
    assert.strictEqual(asyncNotFound, undefined, 'escalade must resolve to undefined when file is not found');

    const syncNotFound = escaladeSync(subDir, (dir, names) => {
      if (names.includes('non-existent-file.xyz')) {
        return 'non-existent-file.xyz';
      }
    });
    assert.strictEqual(syncNotFound, undefined, 'escaladeSync must return undefined when file is not found');

    // 5. Async callback support in escalade
    const asyncCallbackFound = await escalade(subDir, async (dir, names) => {
      if (names.includes('target.config.json')) {
        return 'target.config.json';
      }
    });
    assert.strictEqual(asyncCallbackFound, targetFile, 'escalade must handle async callback');

    console.log('Contract tests passed successfully.');
    process.exit(0);
  } finally {
    try {
      if (fs.existsSync(tmpDir)) {
        fs.rmSync(tmpDir, { recursive: true, force: true });
      }
    } catch (e) {
      // Ignore cleanup error
    }
  }
}

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