@storm-stack/core/dist/chunk-22M3FAZZ.js

A build toolkit and runtime used by Storm Software in TypeScript applications

import { restoreVfs, createVfs } from './chunk-EO2WED4R.js';
import { __VFS_VIRTUAL__ } from './chunk-NPDWYHER.js';
import { createResolver } from './chunk-DSJX5QKP.js';
import { createLog } from './chunk-RDCOIWVB.js';
import { resolveConfig } from './chunk-EAAFBEI6.js';
import { getParsedTypeScriptConfig } from './chunk-ONS37BLK.js';
import { __name } from './chunk-43IZMM3W.js';
import { LogLevelLabel } from '@storm-software/config-tools/types';
import { getEnvPaths } from '@stryke/env/get-env-paths';
import { readJsonFile } from '@stryke/fs/json';
import { listFiles } from '@stryke/fs/list-files';
import { removeFile } from '@stryke/fs/remove-file';
import { hash } from '@stryke/hash/hash';
import { hashDirectory } from '@stryke/hash/hash-files';
import { StormJSON } from '@stryke/json/storm-json';
import { existsSync } from '@stryke/path/exists';
import { relativeToWorkspaceRoot } from '@stryke/path/file-path-fns';
import { getWorkspaceRoot, getProjectRoot } from '@stryke/path/get-workspace-root';
import { joinPaths } from '@stryke/path/join-paths';
import { resolvePackage } from '@stryke/path/resolve';
import { kebabCase } from '@stryke/string-format/kebab-case';
import { uuid } from '@stryke/unique-id/uuid';
import defu from 'defu';

var PROJECT_ROOT_HASH_LENGTH = 45;
function getPrefixedProjectRootHash(name, projectRootHash) {
  const combined = `${kebabCase(name)}_${projectRootHash}`;
  return combined.length > PROJECT_ROOT_HASH_LENGTH ? combined.slice(0, PROJECT_ROOT_HASH_LENGTH) : combined;
}
__name(getPrefixedProjectRootHash, "getPrefixedProjectRootHash");
async function discoverTemplates(path) {
  const result = await Promise.all([
    listFiles(joinPaths(path, "**/*.ts")),
    listFiles(joinPaths(path, "**/*.tsx"))
  ]);
  return result.flat();
}
__name(discoverTemplates, "discoverTemplates");
async function getChecksum(path) {
  return hashDirectory(path, {
    ignore: [
      "node_modules",
      ".git",
      ".nx",
      ".cache",
      ".storm",
      "tmp",
      "dist"
    ]
  });
}
__name(getChecksum, "getChecksum");
async function getPersistedMeta(context) {
  const metaFilePath = joinPaths(context.dataPath, "meta.json");
  if (existsSync(metaFilePath)) {
    try {
      return await readJsonFile(metaFilePath);
    } catch {
      context.log(LogLevelLabel.WARN, `Failed to read meta file at ${metaFilePath}. It may be corrupted.`);
      await removeFile(metaFilePath);
      context.persistedMeta = void 0;
    }
  }
  return void 0;
}
__name(getPersistedMeta, "getPersistedMeta");
async function createContext(inlineConfig, workspaceConfig, options = {}) {
  const workspaceRoot = workspaceConfig?.workspaceRoot ?? getWorkspaceRoot();
  const projectRoot = inlineConfig.root || getProjectRoot() || process.cwd();
  const resolvedWorkspaceConfig = defu(workspaceConfig, {
    workspaceRoot
  });
  let projectJson;
  const projectJsonPath = joinPaths(projectRoot, "project.json");
  if (existsSync(projectJsonPath)) {
    projectJson = await readJsonFile(projectJsonPath);
  }
  let packageJson;
  const packageJsonPath = joinPaths(projectRoot, "package.json");
  if (existsSync(packageJsonPath)) {
    packageJson = await readJsonFile(packageJsonPath);
  } else if (inlineConfig.command === "new") {
    const workspacePackageJsonPath = joinPaths(workspaceRoot, "package.json");
    packageJson = await readJsonFile(workspacePackageJsonPath);
    resolvedWorkspaceConfig.repository ??= typeof packageJson?.repository === "string" ? packageJson.repository : packageJson?.repository?.url;
  } else {
    throw new Error(`The package.json file is missing in the project root directory: ${projectRoot}. Please run the "new" command to create a new Storm Stack project.`);
  }
  const checksum = await getChecksum(projectRoot);
  const meta = {
    buildId: uuid(),
    releaseId: uuid(),
    checksum,
    timestamp: Date.now(),
    projectRootHash: hash(joinPaths(workspaceRoot, projectRoot), {
      maxLength: PROJECT_ROOT_HASH_LENGTH
    }),
    runtimeIdMap: {},
    virtualFiles: {}
  };
  const artifactsPath = joinPaths(workspaceRoot, projectRoot, ".storm");
  const runtimePath = joinPaths(artifactsPath, "runtime");
  const entryPath = joinPaths(artifactsPath, "entry");
  const envPaths = getEnvPaths({
    orgId: "storm-software",
    appId: "storm-stack",
    workspaceRoot
  });
  if (!envPaths.cache) {
    throw new Error("The cache directory could not be determined.");
  }
  envPaths.cache = joinPaths(envPaths.cache, "projects", meta.projectRootHash);
  const partiallyResolvedContext = {
    options: {
      ...resolvedWorkspaceConfig,
      name: projectJson?.name || options.name,
      ...inlineConfig,
      userConfig: {
        config: {}
      },
      inlineConfig,
      projectRoot,
      workspaceConfig: resolvedWorkspaceConfig,
      plugins: {}
    },
    log: createLog(options.name ?? null, defu(inlineConfig, resolvedWorkspaceConfig)),
    meta,
    envPaths,
    artifactsPath,
    runtimePath,
    entryPath,
    dtsPath: joinPaths(envPaths.cache, "dts"),
    runtimeDtsFilePath: joinPaths(projectRoot, "storm.d.ts"),
    dataPath: joinPaths(envPaths.data, "projects", meta.projectRootHash),
    cachePath: envPaths.cache,
    templates: [],
    projectJson,
    packageJson,
    runtime: {
      logs: [],
      storage: [],
      init: []
    },
    packageDeps: {},
    workers: {},
    reflections: {},
    resolver: createResolver({
      workspaceRoot,
      projectRoot,
      cacheDir: envPaths.cache
    }),
    relativeToWorkspaceRoot: relativeToWorkspaceRoot(projectRoot)
  };
  partiallyResolvedContext.options = await resolveConfig(partiallyResolvedContext, inlineConfig, void 0, projectRoot);
  const context = partiallyResolvedContext;
  context.dataPath = joinPaths(context.envPaths.data, "projects", getPrefixedProjectRootHash(context.options.name, context.meta.projectRootHash));
  context.persistedMeta = await getPersistedMeta(context);
  context.templates = (await Promise.all([
    discoverTemplates(context.options.templates),
    discoverTemplates(joinPaths(context.envPaths.config, "templates")),
    discoverTemplates(joinPaths(projectRoot, "templates"))
  ])).flat();
  context.runtimeDtsFilePath = context.options.output.dts ? context.options.output.dts.startsWith(context.options.workspaceRoot) ? context.options.output.dts : joinPaths(context.options.workspaceRoot, context.options.output.dts) : joinPaths(context.options.workspaceRoot, context.options.projectRoot, "storm.d.ts");
  context.tsconfig = getParsedTypeScriptConfig(context.options.workspaceRoot, context.options.projectRoot, context.options.tsconfig);
  if (context.persistedMeta?.checksum === context.meta.checksum) {
    context.log(LogLevelLabel.TRACE, `Restoring the virtual file system (VFS) as the meta checksum has not changed.`);
    context.vfs = restoreVfs(context, {
      runtimeIdMap: context.persistedMeta.runtimeIdMap,
      virtualFiles: context.persistedMeta.virtualFiles
    });
  } else {
    context.vfs = createVfs(context);
  }
  const packagePath = process.env.STORM_STACK_LOCAL ? joinPaths(context.options.workspaceRoot, "dist/packages/core") : await resolvePackage("@storm-stack/core");
  if (!packagePath) {
    throw new Error("Could not resolve the Storm Stack core package. Please ensure it is installed.");
  }
  return context;
}
__name(createContext, "createContext");
function serializeContext(context) {
  return {
    ...context,
    log: null,
    workers: null,
    resolver: null,
    compiler: null,
    unimport: null,
    reflections: Object.entries(context.reflections).reduce((ret, [key, reflection]) => {
      ret[key] = reflection?.serializeType();
      return ret;
    }, {}),
    tsconfig: {
      tsconfigFilePath: context.tsconfig.tsconfigFilePath,
      tsconfigJson: context.tsconfig.tsconfigJson
    },
    vfs: {
      runtimeIdMap: context.vfs.runtimeIdMap.entries().reduce((ret, [key, value]) => {
        ret[key] = value;
        return ret;
      }, {}),
      virtualFiles: context.vfs[__VFS_VIRTUAL__].toJSON(context.artifactsPath)
    }
  };
}
__name(serializeContext, "serializeContext");
function deserializeContext(serialized, logName = null) {
  const context = {
    ...serialized,
    log: createLog(logName, serialized.options),
    reflections: Object.keys(serialized.reflections).reduce((ret, key) => {
      ret[key] = (void 0).from((void 0)(serialized.reflections[key]));
      return ret;
    }, {}),
    resolver: createResolver({
      workspaceRoot: serialized.options.workspaceRoot,
      projectRoot: serialized.options.projectRoot,
      cacheDir: serialized.envPaths.cache
    }),
    vfs: {},
    compiler: {},
    tsconfig: {},
    workers: {},
    unimport: {}
  };
  context.vfs = restoreVfs(context, serialized.vfs);
  context.tsconfig = getParsedTypeScriptConfig(context.options.workspaceRoot, serialized.options.projectRoot, serialized.tsconfig.tsconfigFilePath, serialized.tsconfig.tsconfigJson);
  return context;
}
__name(deserializeContext, "deserializeContext");
async function writeMetaFile(context) {
  const metaFilePath = joinPaths(context.dataPath, "meta.json");
  context.log(LogLevelLabel.DEBUG, `Writing runtime metadata to ${metaFilePath}`);
  context.meta.runtimeIdMap = context.vfs.runtimeIdMap.entries().reduce((map, [id, path]) => {
    map[id] = path;
    return map;
  }, {});
  context.meta.virtualFiles = context.vfs[__VFS_VIRTUAL__].toJSON(context.artifactsPath);
  return context.vfs.writeFileToDisk(metaFilePath, StormJSON.stringify(context.meta));
}
__name(writeMetaFile, "writeMetaFile");

export { PROJECT_ROOT_HASH_LENGTH, createContext, deserializeContext, discoverTemplates, getChecksum, getPersistedMeta, getPrefixedProjectRootHash, serializeContext, writeMetaFile };
//# sourceMappingURL=chunk-22M3FAZZ.js.map
//# sourceMappingURL=chunk-22M3FAZZ.js.map