@alexaegis/advent-of-code-lib/task.function-DLqtA66E.js

Advent of Code Library

import { PerformanceObserver, performance } from "node:perf_hooks";
import "@alexaegis/common";
import "./array.polyfill-r5d1OMxR.js";
import { r as roundToDecimal } from "./round-to-decimal.function-Cwzke1xf.js";
import "js-sdsl";
import "./index-41yGvuWH.js";
import "./map.js";
import { readFile } from "node:fs/promises";
import { normalize, join } from "node:path";
import { existsSync } from "node:fs";
import { white, bgGreen } from "kolorist";
import "./set.js";
const benchTask = async (runner, resources, logger) => {
  if (process.versions["bun"] === void 0) {
    const obs = new PerformanceObserver((list) => {
      list.getEntries().forEach((entry) => {
        logger?.(`${entry.name}: ${roundToDecimal(entry.duration, 2)} ms`);
      });
    });
    obs.observe({ entryTypes: ["measure"], buffered: true });
  }
  performance.mark("runstart");
  const result = await runner(resources.input, resources.args);
  performance.mark("runend");
  performance.measure("run", "runstart", "runend");
  return result;
};
const findNearestDirectoryNamed = (directoryName, cwd = process.cwd(), collection = []) => {
  const path = normalize(cwd);
  if (existsSync(join(path, directoryName))) {
    return path;
  }
  const parentPath = join(path, "..");
  return parentPath === path ? void 0 : findNearestDirectoryNamed(directoryName, parentPath, collection);
};
const loadTaskResources = async (taskMetadata, file = "input.txt") => {
  const resourcesRoot = findNearestDirectoryNamed("resources");
  if (!resourcesRoot) {
    throw new Error("resource directory not found");
  }
  const baseUrl = join(
    resourcesRoot,
    "resources",
    taskMetadata.year.toString(),
    taskMetadata.day.toString().padStart(2, "0")
  );
  const [input, args] = await Promise.all([
    readFile(join(baseUrl, file), {
      encoding: "utf8"
    }),
    // TODO: redo with @aa/node-common (strip extension and replace)
    readFile(join(baseUrl, `${file.split(/(.*)\..*/)[1]}.args.json`), {
      encoding: "utf8"
    }).catch(() => void 0)
  ]);
  return { input, args: args ? JSON.parse(args) : void 0 };
};
const createLogger = (metadata) => (message) => {
  console.log(
    white(bgGreen(`[aoc:${metadata.year}-${metadata.day.toString().padStart(2, "0")}]`)),
    message
  );
};
const isTaskMetadata = (o) => Object.hasOwn(o, "year") && Object.hasOwn(o, "day");
const task = async (solution, taskMetadata, resourcesOverride) => {
  if (process.env["RUN"]) {
    const log = createLogger(taskMetadata);
    log("starting...");
    let resources = typeof resourcesOverride === "object" ? resourcesOverride : await loadTaskResources(
      taskMetadata,
      resourcesOverride
    );
    if (process.env["RESOURCE"]) {
      resources = await loadTaskResources(
        taskMetadata,
        process.env["RESOURCE"]
      );
    }
    const result = await benchTask(solution, resources, log);
    log(`result:
${String(result)}`);
    return result;
  } else {
    return void 0;
  }
};
export {
  benchTask as b,
  createLogger as c,
  isTaskMetadata as i,
  loadTaskResources as l,
  task as t
};