has-flag 4.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/has-flag@4.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/has-flag@4.0.0
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:3c3d12213e504c2aa47a2e67272ee09585737dc5f36013120410a35ca9cb56be","constraints":{"executionContext":"node"},"contract":["hasFlag checks CLI arguments for the presence of a specific flag","hasFlag automatically prepends single dash prefix to single-character flag names","hasFlag automatically prepends double dash prefix to multi-character flag names","hasFlag preserves explicit single or double dash prefixes when provided","hasFlag ignores flags appearing after the terminator argument","hasFlag defaults to inspecting process.argv when custom argv array is omitted"],"goal":"verify pkg:npm/has-flag@4.0.0","kind":"HOW","packages":["pkg:npm/has-flag@4.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","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/has-flag@4.0.0"],"schemaVersion":1,"subject":"pkg:npm/has-flag@4.0.0","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-has-flag",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-has-flag",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "has-flag": "4.0.0"
      }
    },
    "node_modules/has-flag": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    }
  }
}

{
  "name": "sample-has-flag",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room code sample for has-flag@4.0.0",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "has-flag": "4.0.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/has-flag@4.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/has-flag@4.0.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

'use strict';

const hasFlag = require('has-flag');

/**
 * Checks whether a command-line flag is present in the specified argument list or process.argv.
 *
 * @param {string} flag - The flag name to look for (with or without leading dashes).
 * @param {string[]} [argv] - Argument array to search within, defaulting to process.argv.
 * @returns {boolean} True if the flag is present before any terminator argument ('--').
 */
function checkFlag(flag, argv) {
  return hasFlag(flag, argv);
}

/**
 * Checks if any of the provided flag aliases are present in the argument list.
 *
 * @param {string[]} flags - Array of flag names or aliases.
 * @param {string[]} [argv] - Argument array to search within.
 * @returns {boolean} True if at least one flag is present.
 */
function checkAnyFlag(flags, argv) {
  return flags.some((flag) => hasFlag(flag, argv));
}

module.exports = {
  hasFlag,
  checkFlag,
  checkAnyFlag
};

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);
const { hasFlag, checkFlag, checkAnyFlag } = require('../src/index.js');

async function testAll() {
  // 1. Export verification
  assert.equal(typeof hasFlag, 'function', 'hasFlag export must be a function');
  assert.equal(typeof checkFlag, 'function', 'checkFlag helper must be a function');
  assert.equal(typeof checkAnyFlag, 'function', 'checkAnyFlag helper must be a function');

  // 2. Basic flag matching with custom argv
  assert.equal(hasFlag('unicorn', ['--unicorn']), true, 'multi-character flag matched with auto prefix');
  assert.equal(hasFlag('--unicorn', ['--unicorn']), true, 'multi-character flag matched with explicit prefix');
  assert.equal(hasFlag('f', ['-f']), true, 'single-character flag matched with auto single dash');
  assert.equal(hasFlag('-f', ['-f']), true, 'single-character flag matched with explicit single dash');
  assert.equal(hasFlag('foo', ['-f', '--bar']), false, 'missing flag returns false');

  // 3. Prefix handling rules
  assert.equal(hasFlag('verbose', ['--verbose']), true, 'matches long flag');
  assert.equal(hasFlag('v', ['-v']), true, 'matches short flag');
  assert.equal(hasFlag('-v', ['-v']), true, 'matches explicit short flag');
  assert.equal(hasFlag('--verbose', ['--verbose']), true, 'matches explicit long flag');
  assert.equal(hasFlag('verbose', ['-verbose']), false, 'multi-char flag does not match single dash');
  assert.equal(hasFlag('v', ['--v']), false, 'single-char flag does not match double dash unless explicit');

  // 4. Terminator ('--') handling
  const argvWithTerminator = ['--foo', '--', '--bar', '-b'];
  assert.equal(hasFlag('foo', argvWithTerminator), true, 'flag before terminator is detected');
  assert.equal(hasFlag('bar', argvWithTerminator), false, 'flag after terminator is ignored');
  assert.equal(hasFlag('b', argvWithTerminator), false, 'short flag after terminator is ignored');

  // 5. Default process.argv fallback
  const originalArgv = process.argv;
  try {
    process.argv = ['node', 'script.js', '--custom-test-flag', '-q'];
    assert.equal(hasFlag('custom-test-flag'), true, 'detects flag in default process.argv');
    assert.equal(hasFlag('q'), true, 'detects short flag in default process.argv');
    assert.equal(hasFlag('missing-flag'), false, 'returns false for absent flag in process.argv');
  } finally {
    process.argv = originalArgv;
  }

  // 6. Helpers checkFlag and checkAnyFlag
  assert.equal(checkFlag('port', ['--port', '8080']), true, 'checkFlag works correctly');
  assert.equal(checkAnyFlag(['help', 'h', '?'], ['-h']), true, 'checkAnyFlag detects short alias');
  assert.equal(checkAnyFlag(['help', 'h', '?'], ['--help']), true, 'checkAnyFlag detects long alias');
  assert.equal(checkAnyFlag(['help', 'h', '?'], ['--version']), false, 'checkAnyFlag returns false when none present');

  console.log('All has-flag contract tests passed successfully.');
}

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