lazy-val 1.0.5

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/lazy-val@1.0.5
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/lazy-val@1.0.5

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:7bcbb1b89c0cfc1ccf31677c274fd58cbe55e80db2eee422c541bca3c4155b9b","contract":["Lazy constructor initializes with creator function while hasValue remains false before evaluation","Lazy.value invokes creator once, caches the resulting Promise, and marks hasValue as true","Lazy.value setter explicitly sets cached value and clears the creator function","Lazy handles async promise resolution and rejection correctly across repeated accesses"],"goal":"verify pkg:npm/lazy-val@1.0.5","kind":"HOW","packages":["pkg:npm/lazy-val@1.0.5"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"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/lazy-val@1.0.5"],"schemaVersion":1,"subject":"pkg:npm/lazy-val@1.0.5","verifierAdapter":"node-typescript@1"}

import { Lazy } from 'lazy-val';

/**
 * Creates a lazy value initialized with the given asynchronous creator function.
 *
 * @template T
 * @param {() => Promise<T>} creator - Function to compute the value asynchronously on first access.
 * @returns {Lazy<T>} The lazy evaluation wrapper.
 */
export function createLazy(creator) {
  return new Lazy(creator);
}

export { Lazy };

{
  "name": "sample-lazy-val",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-lazy-val",
      "version": "1.0.0",
      "dependencies": {
        "lazy-val": "1.0.5"
      }
    },
    "node_modules/lazy-val": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",
      "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-lazy-val",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "dependencies": {
    "lazy-val": "1.0.5"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/lazy-val@1.0.5",
  "kind": "HOW",
  "packages": [
    "pkg:npm/lazy-val@1.0.5"
  ]
}

import assert from 'node:assert/strict';
import { Lazy } from 'lazy-val';
import { createLazy } from '../index.js';

// 1. Lazy constructor initializes with creator function while hasValue remains false before evaluation
{
  let called = false;
  const lazy = createLazy(async () => {
    called = true;
    return 'initialized';
  });

  assert.equal(lazy.hasValue, false);
  assert.equal(called, false);
}

// 2. Lazy.value invokes creator once, caches the resulting Promise, and marks hasValue as true
{
  let callCount = 0;
  const lazy = new Lazy(async () => {
    callCount++;
    return 42;
  });

  assert.equal(lazy.hasValue, false);
  assert.equal(callCount, 0);

  const p1 = lazy.value;
  assert.equal(lazy.hasValue, true);
  assert.equal(callCount, 1);

  const p2 = lazy.value;
  assert.equal(callCount, 1);
  assert.equal(p1, p2);

  const val1 = await p1;
  const val2 = await p2;
  assert.equal(val1, 42);
  assert.equal(val2, 42);
}

// 3. Lazy.value setter explicitly sets cached value and clears the creator function
{
  let callCount = 0;
  const lazy = new Lazy(async () => {
    callCount++;
    return 'original';
  });

  assert.equal(lazy.hasValue, false);

  const overridePromise = Promise.resolve('override');
  lazy.value = overridePromise;

  assert.equal(lazy.hasValue, true);
  assert.equal(callCount, 0);

  const p = lazy.value;
  assert.equal(p, overridePromise);
  assert.equal(callCount, 0);

  const result = await p;
  assert.equal(result, 'override');
}

// 4. Lazy handles async promise resolution and rejection correctly across repeated accesses
{
  const testError = new Error('async computation failed');
  let callCount = 0;
  const lazyFailing = new Lazy(async () => {
    callCount++;
    throw testError;
  });

  assert.equal(lazyFailing.hasValue, false);

  const p1 = lazyFailing.value;
  assert.equal(lazyFailing.hasValue, true);
  assert.equal(callCount, 1);

  const p2 = lazyFailing.value;
  assert.equal(p1, p2);
  assert.equal(callCount, 1);

  await assert.rejects(p1, (err) => {
    assert.equal(err, testError);
    return true;
  });

  await assert.rejects(p2, (err) => {
    assert.equal(err, testError);
    return true;
  });
}