@codama/renderers-core/dist/index.node.mjs

Core types and helpers for Codama renderers to use

import { mkdirSync, existsSync, rmSync, writeFileSync, readFileSync } from 'fs';
import { CodamaError, CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND } from '@codama/errors';
import { join, dirname } from 'path';
import { mapVisitor } from '@codama/visitors-core';

// src/fragment.ts
function mapFragmentContent(fragment, mapContent) {
  return setFragmentContent(fragment, mapContent(fragment.content));
}
async function mapFragmentContentAsync(fragment, mapContent) {
  return setFragmentContent(fragment, await mapContent(fragment.content));
}
function setFragmentContent(fragment, content) {
  return Object.freeze({ ...fragment, content });
}
function createFragmentTemplate(template, items, isFragment, mergeFragments) {
  const fragments = items.filter(isFragment);
  const zippedItems = items.map((item, i) => {
    const itemPrefix = template[i];
    if (typeof item === "undefined") return itemPrefix;
    if (isFragment(item)) return itemPrefix + item.content;
    return itemPrefix + String(item);
  });
  return mergeFragments(fragments, () => zippedItems.join("") + template[template.length - 1]);
}
function joinPath(...paths) {
  return join(...paths);
}
function pathDirectory(path) {
  return dirname(path);
}

// src/fs.ts
function createDirectory(path) {
  mkdirSync(path, { recursive: true });
}
function deleteDirectory(path) {
  if (existsSync(path)) {
    rmSync(path, { recursive: true });
  }
}
function writeFile(path, content) {
  const directory = pathDirectory(path);
  if (!existsSync(directory)) {
    createDirectory(directory);
  }
  writeFileSync(path, content);
}
function fileExists(path) {
  return existsSync(path);
}
function readFile(path) {
  return readFileSync(path, "utf-8");
}
function readJson(path) {
  return JSON.parse(readFile(path));
}
function createRenderMap(pathOrEntries, content) {
  let entries = [];
  if (typeof pathOrEntries === "string" && pathOrEntries !== void 0 && content !== void 0) {
    entries = [[pathOrEntries, content]];
  } else if (typeof pathOrEntries === "object" && pathOrEntries !== null) {
    entries = Object.entries(pathOrEntries).flatMap(
      ([key, value]) => value === void 0 ? [] : [[key, value]]
    );
  }
  return Object.freeze(new Map(entries));
}
function addToRenderMap(renderMap, path, content) {
  return mergeRenderMaps([renderMap, createRenderMap(path, content)]);
}
function removeFromRenderMap(renderMap, path) {
  const newMap = new Map(renderMap);
  newMap.delete(path);
  return Object.freeze(newMap);
}
function mergeRenderMaps(renderMaps) {
  if (renderMaps.length === 0) return createRenderMap();
  if (renderMaps.length === 1) return renderMaps[0];
  const merged = new Map(renderMaps[0]);
  for (const map of renderMaps.slice(1)) {
    for (const [key, value] of map) {
      merged.set(key, value);
    }
  }
  return Object.freeze(merged);
}
function mapRenderMapFragment(renderMap, fn) {
  return Object.freeze(new Map([...[...renderMap.entries()].map(([key, value]) => [key, fn(value, key)])]));
}
async function mapRenderMapFragmentAsync(renderMap, fn) {
  return Object.freeze(
    new Map(
      await Promise.all([
        ...[...renderMap.entries()].map(async ([key, value]) => [key, await fn(value, key)])
      ])
    )
  );
}
function mapRenderMapContent(renderMap, fn) {
  return mapRenderMapFragment(
    renderMap,
    (fragment, path) => mapFragmentContent(fragment, (content) => fn(content, path))
  );
}
async function mapRenderMapContentAsync(renderMap, fn) {
  return await mapRenderMapFragmentAsync(
    renderMap,
    (fragment, path) => mapFragmentContentAsync(fragment, (content) => fn(content, path))
  );
}
function getFromRenderMap(renderMap, path) {
  const value = renderMap.get(path);
  if (value === void 0) {
    throw new CodamaError(CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND, { key: path });
  }
  return value;
}
function renderMapContains(renderMap, path, value) {
  const { content } = getFromRenderMap(renderMap, path);
  return typeof value === "string" ? content.includes(value) : value.test(content);
}
function writeRenderMap(renderMap, basePath) {
  renderMap.forEach(({ content }, relativePath) => {
    writeFile(joinPath(basePath, relativePath), content);
  });
}
function writeRenderMapVisitor(visitor, basePath) {
  return mapVisitor(visitor, (renderMap) => writeRenderMap(renderMap, basePath));
}

export { addToRenderMap, createDirectory, createFragmentTemplate, createRenderMap, deleteDirectory, fileExists, getFromRenderMap, joinPath, mapFragmentContent, mapFragmentContentAsync, mapRenderMapContent, mapRenderMapContentAsync, mapRenderMapFragment, mapRenderMapFragmentAsync, mergeRenderMaps, pathDirectory, readFile, readJson, removeFromRenderMap, renderMapContains, setFragmentContent, writeFile, writeRenderMap, writeRenderMapVisitor };
//# sourceMappingURL=index.node.mjs.map
//# sourceMappingURL=index.node.mjs.map