@platforma-sdk/block-tools 2.1.5

package/dist/lib.cjs

@@ -0,0 +1,629 @@
+'use strict';
+
+var zod = require('zod');
+var plModelMiddleLayer = require('@milaboratories/pl-model-middle-layer');
+require('yaml');
+var fsp2 = require('fs/promises');
+require('os');
+var crypto = require('crypto');
+var semver = require('semver/preload');
+var pathPosix = require('path/posix');
+var path = require('path');
+var clientS3 = require('@aws-sdk/client-s3');
+var fs = require('fs');
+var mime = require('mime-types');
+var tar = require('tar');
+var tsHelpers = require('@milaboratories/ts-helpers');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fsp2__default = /*#__PURE__*/_interopDefault(fsp2);
+var semver__default = /*#__PURE__*/_interopDefault(semver);
+var pathPosix__default = /*#__PURE__*/_interopDefault(pathPosix);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var mime__namespace = /*#__PURE__*/_interopNamespace(mime);
+var tar__namespace = /*#__PURE__*/_interopNamespace(tar);
+
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/registry_v1/index.ts
+var registry_v1_exports = {};
+__export(registry_v1_exports, {
+  GlobalOverviewPath: () => GlobalOverviewPath,
+  MetaFile: () => MetaFile,
+  PlPackageConfigData: () => PlPackageConfigData,
+  PlPackageJsonConfigFile: () => PlPackageJsonConfigFile,
+  PlPackageYamlConfigFile: () => PlPackageYamlConfigFile,
+  PlRegCommonConfigData: () => PlRegCommonConfigData,
+  PlRegFullPackageConfigData: () => PlRegFullPackageConfigData,
+  PlRegPackageConfig: () => PlRegPackageConfig,
+  PlRegPackageConfigDataShard: () => PlRegPackageConfigDataShard,
+  packageContentPrefix: () => packageContentPrefix,
+  packageOverviewPath: () => packageOverviewPath,
+  payloadFilePath: () => payloadFilePath
+});
+
+// src/registry_v1/v1_repo_schema.ts
+var MainPrefix = "v1/";
+function packageContentPrefix(bp) {
+  return `${MainPrefix}${bp.organization}/${bp.package}/${bp.version}`;
+}
+function payloadFilePath(bp, file) {
+  return `${MainPrefix}${bp.organization}/${bp.package}/${bp.version}/${file}`;
+}
+function packageOverviewPath(bp) {
+  return `${MainPrefix}${bp.organization}/${bp.package}/overview.json`;
+}
+var GlobalOverviewPath = `${MainPrefix}overview.json`;
+var MetaFile = "meta.json";
+var PlRegAddress = zod.z.string().regex(/^(?:s3:|file:)/);
+var PlPackageConfigData = zod.z.object({
+  organization: zod.z.string(),
+  package: zod.z.string(),
+  version: plModelMiddleLayer.SemVer.optional(),
+  files: zod.z.record(zod.z.string().regex(/^[^\/]+$/), zod.z.string()).default({}),
+  meta: zod.z.object({}).passthrough()
+});
+var PlRegCommonConfigData = zod.z.object({
+  registries: zod.z.record(zod.z.string(), PlRegAddress).default({}),
+  registry: zod.z.string().optional()
+});
+var PlRegFullPackageConfigData = PlRegCommonConfigData.merge(PlPackageConfigData).required(
+  { registry: true, version: true }
+);
+var PlRegPackageConfigDataShard = PlRegFullPackageConfigData.partial().required({
+  registries: true,
+  files: true
+});
+var PlPackageJsonConfigFile = "pl.package.json";
+var PlPackageYamlConfigFile = "pl.package.yaml";
+async function tryLoadFile(file, map) {
+  try {
+    return map(await fsp2__default.default.readFile(file));
+  } catch (err) {
+    if (err.code == "ENOENT") return void 0;
+    else throw new Error("", { cause: err });
+  }
+}
+var VersionUpdatesPrefix = "_updates_v1/per_package_version/";
+function packageUpdatePath(bp, seed) {
+  return `${VersionUpdatesPrefix}${bp.organization}/${bp.package}/${bp.version}/${seed}`;
+}
+var PackageUpdatePattern = /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<pkg>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/;
+var GlobalUpdateSeedInFile = "_updates_v1/_global_update_in";
+var GlobalUpdateSeedOutFile = "_updates_v1/_global_update_out";
+var BlockRegistry = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+  }
+  constructNewPackage(pack) {
+    return new BlockRegistryPackConstructor(this.storage, pack);
+  }
+  async updateRegistry() {
+    this.logger?.info("Initiating registry refresh...");
+    const packagesToUpdate = /* @__PURE__ */ new Map();
+    const seedPaths = [];
+    const rawSeedPaths = await this.storage.listFiles(VersionUpdatesPrefix);
+    this.logger?.info("Packages to be updated:");
+    for (const seedPath of rawSeedPaths) {
+      const match = seedPath.match(PackageUpdatePattern);
+      if (!match) continue;
+      seedPaths.push(seedPath);
+      const { packageKeyWithoutVersion, organization, pkg, version, seed } = match.groups;
+      let update = packagesToUpdate.get(packageKeyWithoutVersion);
+      if (!update) {
+        packagesToUpdate.set(packageKeyWithoutVersion, {
+          package: { organization, package: pkg },
+          versions: /* @__PURE__ */ new Set([version])
+        });
+      } else if (!update.versions.has(version)) {
+        update.versions.add(version);
+      }
+      this.logger?.info(`  - ${organization}:${pkg}:${version}`);
+    }
+    const overviewContent = await this.storage.getFile(GlobalOverviewPath);
+    let overview = overviewContent === void 0 ? [] : JSON.parse(overviewContent.toString());
+    this.logger?.info(`Global overview loaded, ${overview.length} records`);
+    for (const [, packageInfo] of packagesToUpdate.entries()) {
+      const overviewFile = packageOverviewPath(packageInfo.package);
+      const pOverviewContent = await this.storage.getFile(overviewFile);
+      let packageOverview = pOverviewContent === void 0 ? [] : JSON.parse(pOverviewContent.toString());
+      this.logger?.info(
+        `Updating ${packageInfo.package.organization}:${packageInfo.package.package} overview, ${packageOverview.length} records`
+      );
+      packageOverview = packageOverview.filter((e) => !packageInfo.versions.has(e.version));
+      for (const [v] of packageInfo.versions.entries()) {
+        const version = v.toString();
+        const metaContent = await this.storage.getFile(
+          payloadFilePath(
+            {
+              ...packageInfo.package,
+              version
+            },
+            MetaFile
+          )
+        );
+        if (!metaContent) continue;
+        packageOverview.push({ version, meta: JSON.parse(metaContent.toString()) });
+      }
+      packageOverview.sort((e1, e2) => semver__default.default.compare(e2.version, e1.version));
+      await this.storage.putFile(overviewFile, Buffer.from(JSON.stringify(packageOverview)));
+      this.logger?.info(`Done (${packageOverview.length} records)`);
+      overview = overview.filter(
+        (e) => e.organization !== packageInfo.package.organization || e.package !== packageInfo.package.package
+      );
+      overview.push({
+        organization: packageInfo.package.organization,
+        package: packageInfo.package.package,
+        allVersions: packageOverview.map((e) => e.version).reverse(),
+        latestVersion: packageOverview[0].version,
+        latestMeta: packageOverview[0].meta
+      });
+    }
+    await this.storage.putFile(GlobalOverviewPath, Buffer.from(JSON.stringify(overview)));
+    this.logger?.info(`Global overview updated (${overview.length} records)`);
+    await this.storage.deleteFiles(...seedPaths.map((sp) => `${VersionUpdatesPrefix}${sp}`));
+    this.logger?.info(`Version update requests cleared`);
+  }
+  async updateIfNeeded(force = false) {
+    this.logger?.info(`Checking if registry requires refresh...`);
+    const updateRequestSeed = await this.storage.getFile(GlobalUpdateSeedInFile);
+    const currentUpdatedSeed = await this.storage.getFile(GlobalUpdateSeedOutFile);
+    if (!force && updateRequestSeed === void 0 && currentUpdatedSeed === void 0) return;
+    if (!force && updateRequestSeed !== void 0 && currentUpdatedSeed !== void 0 && updateRequestSeed.equals(currentUpdatedSeed))
+      return;
+    await this.updateRegistry();
+    if (updateRequestSeed) {
+      await this.storage.putFile(GlobalUpdateSeedOutFile, updateRequestSeed);
+      this.logger?.info(`Refresh finished`);
+    }
+  }
+  async getPackageOverview(name) {
+    const content = await this.storage.getFile(packageOverviewPath(name));
+    if (content === void 0) return void 0;
+    return JSON.parse(content.toString());
+  }
+  async getGlobalOverview() {
+    const content = await this.storage.getFile(GlobalOverviewPath);
+    if (content === void 0) return void 0;
+    return JSON.parse(content.toString());
+  }
+};
+var BlockRegistryPackConstructor = class {
+  constructor(storage, name) {
+    this.storage = storage;
+    this.name = name;
+  }
+  metaAdded = false;
+  seed = crypto.randomUUID();
+  async addFile(file, content) {
+    await this.storage.putFile(payloadFilePath(this.name, file), content);
+  }
+  async writeMeta(meta) {
+    await this.addFile(MetaFile, Buffer.from(JSON.stringify(meta)));
+    this.metaAdded = true;
+  }
+  async finish() {
+    if (!this.metaAdded) throw new Error("meta not added");
+    await this.storage.putFile(packageUpdatePath(this.name, this.seed), Buffer.of(0));
+    await this.storage.putFile(GlobalUpdateSeedInFile, Buffer.from(this.seed));
+  }
+};
+var S3Storage = class {
+  constructor(client, bucket, root) {
+    this.client = client;
+    this.bucket = bucket;
+    this.root = root;
+  }
+  async getFile(file) {
+    try {
+      return Buffer.from(
+        await (await this.client.getObject({
+          Bucket: this.bucket,
+          Key: pathPosix__default.default.join(this.root, file)
+        })).Body.transformToByteArray()
+      );
+    } catch (e) {
+      if (e.name === "NoSuchKey") return void 0;
+      else throw e;
+    }
+  }
+  async listFiles(prefix) {
+    const listRoot = pathPosix__default.default.join(this.root, prefix);
+    const paginator = clientS3.paginateListObjectsV2(
+      { client: this.client },
+      {
+        Bucket: this.bucket,
+        Prefix: listRoot
+      }
+    );
+    const result = [];
+    for await (const page of paginator)
+      result.push(...page.Contents.map((e) => pathPosix__default.default.relative(listRoot, e.Key)));
+    return result;
+  }
+  async putFile(file, buffer) {
+    await this.client.putObject({
+      Bucket: this.bucket,
+      Key: pathPosix__default.default.join(this.root, file),
+      Body: buffer
+    });
+  }
+  async deleteFiles(...files) {
+    const results = await this.client.deleteObjects({
+      Bucket: this.bucket,
+      Delete: {
+        Objects: files.map((file) => ({
+          Key: pathPosix__default.default.join(this.root, file)
+        }))
+      }
+    });
+    if (results.Errors !== void 0 && results.Errors.length > 0)
+      throw new Error(`Errors encountered while deleting files: ${results.Errors.join("\n")}`);
+  }
+};
+var FSStorage = class {
+  /** Absolute path */
+  root;
+  constructor(_root) {
+    this.root = path__default.default.resolve(_root);
+  }
+  toAbsolutePath(localPath) {
+    if (pathPosix__default.default.isAbsolute(localPath)) throw new Error("absolute path");
+    return path__default.default.resolve(this.root, localPath.split(pathPosix__default.default.sep).join(path__default.default.sep));
+  }
+  async getFile(address) {
+    try {
+      return await fs__namespace.promises.readFile(this.toAbsolutePath(address));
+    } catch (err) {
+      if (err.code == "ENOENT") return void 0;
+      else throw new Error("", { cause: err });
+    }
+  }
+  async listFiles(prefix) {
+    try {
+      const listRoot = this.toAbsolutePath(prefix);
+      return (await fs__namespace.promises.readdir(listRoot, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).map(
+        (e) => path__default.default.relative(listRoot, path__default.default.resolve(e.path, e.name)).split(path__default.default.sep).join(pathPosix__default.default.sep)
+      );
+    } catch (err) {
+      if (err.code == "ENOENT") return [];
+      else throw new Error("", { cause: err });
+    }
+  }
+  async putFile(address, buffer) {
+    const absoluteAddress = this.toAbsolutePath(address);
+    await fs__namespace.promises.mkdir(path__default.default.dirname(absoluteAddress), { recursive: true });
+    await fs__namespace.promises.writeFile(absoluteAddress, buffer);
+  }
+  async deleteFiles(...files) {
+    for (const file of files) await fs__namespace.promises.rm(this.toAbsolutePath(file));
+  }
+};
+function storageByUrl(address) {
+  const url = new URL(address, `file:${path__default.default.resolve(".").split(path__default.default.sep).join(pathPosix__default.default.sep)}/`);
+  switch (url.protocol) {
+    case "file:":
+      const root = path__default.default.resolve(url.pathname);
+      return new FSStorage(root);
+    case "s3:":
+      const options = {};
+      const region = url.searchParams.get("region");
+      if (region) options.region = region;
+      const bucket = url.hostname;
+      return new S3Storage(new clientS3.S3(options), bucket, url.pathname.replace(/^\//, ""));
+    default:
+      throw new Error(`Unknown protocol: ${url.protocol}`);
+  }
+}
+
+// src/registry_v1/config.ts
+var PlRegPackageConfig = class {
+  constructor(conf) {
+    this.conf = conf;
+  }
+  createRegistry(logger) {
+    let address = this.conf.registry;
+    if (!address.startsWith("file:") && !address.startsWith("s3:")) {
+      const regByAlias = this.conf.registries[address];
+      if (!regByAlias) throw new Error(`Registry with alias "${address}" not found`);
+      address = regByAlias;
+    }
+    return new BlockRegistry(storageByUrl(address), logger);
+  }
+  get fullPackageName() {
+    return {
+      organization: this.conf.organization,
+      package: this.conf.package,
+      version: this.conf.version
+    };
+  }
+};
+function tryResolve(root, request) {
+  try {
+    return __require.resolve(request, {
+      paths: [root]
+    });
+  } catch (err) {
+    if (err.code !== "MODULE_NOT_FOUND") throw err;
+  }
+  return void 0;
+}
+function ResolvedModuleFile(moduleRoot) {
+  return zod.z.string().transform((request, ctx) => {
+    const result = tryResolve(moduleRoot, request);
+    if (result === void 0) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `Can't resolve ${request} against ${moduleRoot}`
+      });
+      return zod.z.NEVER;
+    }
+    return {
+      type: "absolute-file",
+      file: result
+    };
+  });
+}
+function ResolvedModuleFolder(moduleRoot, ...indexFilesToLookFor) {
+  return zod.z.string().transform((request, ctx) => {
+    const requestWithSlash = request.endsWith("/") ? request : `${request}/`;
+    for (const idxFile of indexFilesToLookFor) {
+      const result = tryResolve(moduleRoot, requestWithSlash + idxFile);
+      if (result !== void 0) {
+        if (!result.endsWith(idxFile))
+          throw new Error(`Unexpected resolve result ${result} with index file ${idxFile}`);
+        return {
+          type: "absolute-folder",
+          folder: result.slice(0, result.length - idxFile.length)
+        };
+      }
+    }
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(", ")})`
+    });
+    return zod.z.NEVER;
+  });
+}
+function mapLocalToAbsolute(root) {
+  return (value) => value.type === "relative" ? { type: "absolute-file", file: path__default.default.resolve(root, value.path) } : value;
+}
+function absoluteToString() {
+  return async (value) => {
+    if (value.type === "absolute-file")
+      return await fsp2__default.default.readFile(value.file, { encoding: "utf-8" });
+    else return value.content;
+  };
+}
+function absoluteToBase64() {
+  return async (value) => {
+    if (value.type === "absolute-file") {
+      const mimeType = mime__namespace.lookup(value.file);
+      if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.file}.`);
+      return {
+        type: "explicit-base64",
+        mimeType,
+        content: await fsp2__default.default.readFile(value.file, { encoding: "base64" })
+      };
+    } else return value;
+  };
+}
+function cpAbsoluteToRelative(dstFolder, fileAccumulator) {
+  return async (value) => {
+    if (value.type === "absolute-file") {
+      const fileName = path__default.default.basename(value.file);
+      const dst = path__default.default.resolve(dstFolder, fileName);
+      fileAccumulator?.push(fileName);
+      await fsp2__default.default.cp(value.file, dst);
+      return { type: "relative", path: fileName };
+    } else return value;
+  };
+}
+function packFolderToRelativeTgz(dstFolder, tgzName, fileAccumulator) {
+  if (!tgzName.endsWith(".tgz")) throw new Error(`Unexpected tgz file name: ${tgzName}`);
+  return async (value) => {
+    const dst = path__default.default.resolve(dstFolder, tgzName);
+    await tar__namespace.create(
+      {
+        gzip: true,
+        file: dst,
+        cwd: value.folder
+      },
+      [value.folder]
+    );
+    fileAccumulator?.push(tgzName);
+    return { type: "relative", path: tgzName };
+  };
+}
+function mapRemoteToAbsolute(rootUrl) {
+  const rootWithSlash = rootUrl.endsWith("/") ? rootUrl : `${rootUrl}/`;
+  return (value) => value.type === "relative" ? { type: "absolute-url", url: rootWithSlash + value.path } : value;
+}
+function BlockComponentsDescription(moduleRoot) {
+  return plModelMiddleLayer.BlockComponents(
+    ResolvedModuleFile(moduleRoot),
+    ResolvedModuleFolder(moduleRoot, "index.html")
+  );
+}
+function BlockComponentsConsolidate(dstFolder, fileAccumulator) {
+  return plModelMiddleLayer.BlockComponents(
+    plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
+    plModelMiddleLayer.ContentAbsoluteFolder.transform(packFolderToRelativeTgz(dstFolder, "ui.tgz", fileAccumulator))
+  ).pipe(plModelMiddleLayer.BlockComponentsManifest);
+}
+function BlockComponentsAbsoluteUrl(prefix) {
+  return plModelMiddleLayer.BlockComponents(
+    plModelMiddleLayer.ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
+    plModelMiddleLayer.ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
+  );
+}
+function BlockPackMetaDescription(root) {
+  return plModelMiddleLayer.BlockPackMeta(
+    plModelMiddleLayer.DescriptionContentText.transform(mapLocalToAbsolute(root)),
+    plModelMiddleLayer.DescriptionContentBinary.transform(mapLocalToAbsolute(root))
+  );
+}
+function BlockPackMetaConsolidate(dstFolder, fileAccumulator) {
+  return plModelMiddleLayer.BlockPackMeta(
+    plModelMiddleLayer.ContentAbsoluteTextLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
+    plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator))
+  );
+}
+plModelMiddleLayer.BlockPackMeta(
+  plModelMiddleLayer.ContentAbsoluteTextLocal.transform(absoluteToString()),
+  plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(absoluteToBase64())
+).pipe(plModelMiddleLayer.BlockPackMetaEmbeddedContent);
+
+// src/v2/model/index.ts
+function ResolvedBlockPackDescriptionFromPackageJson(root) {
+  return plModelMiddleLayer.CreateBlockPackDescriptionSchema(
+    BlockComponentsDescription(root),
+    BlockPackMetaDescription(root)
+  );
+}
+function BlockPackDescriptionConsolidateToFolder(dstFolder, fileAccumulator) {
+  return plModelMiddleLayer.CreateBlockPackDescriptionSchema(
+    BlockComponentsConsolidate(dstFolder, fileAccumulator),
+    //BlockPackMetaToExplicit
+    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
+  ).pipe(BlockPackDescriptionManifest);
+}
+var BlockPackDescriptionManifest = plModelMiddleLayer.CreateBlockPackDescriptionSchema(
+  plModelMiddleLayer.BlockComponentsManifest,
+  plModelMiddleLayer.BlockPackMetaManifest
+);
+var BlockPackManifest = BlockPackDescriptionManifest.extend({
+  schema: zod.z.literal("v1"),
+  files: zod.z.array(zod.z.string())
+});
+var BlockPackManifestFile = "manifest.json";
+async function buildBlockPackDist(description, dst) {
+  await fsp2__default.default.mkdir(dst, { recursive: true });
+  const files = [];
+  const descriptionRelative = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(
+    description
+  );
+  const manifest = BlockPackManifest.parse({
+    schema: "v1",
+    ...descriptionRelative,
+    files
+  });
+  await fsp2__default.default.writeFile(path__default.default.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
+  return manifest;
+}
+var BlockDescriptionPackageJsonField = "block";
+var ConventionPackageNamePattern = /(?:@[a-zA-Z0-9-.]+\/)?(?<organization>[a-zA-Z0-9-]+)\.(?<name>[a-zA-Z0-9-]+)/;
+function parsePackageName(packageName) {
+  const match = packageName.match(ConventionPackageNamePattern);
+  if (!match)
+    throw new Error(
+      `Malformed package name (${packageName}), can't infer organization and block pack name.`
+    );
+  const { name, organization } = match.groups;
+  return { name, organization };
+}
+async function tryLoadPackDescription(moduleRoot) {
+  const fullPackageJsonPath = path__default.default.resolve(moduleRoot, "package.json");
+  try {
+    const packageJson = await tryLoadFile(
+      fullPackageJsonPath,
+      (buf) => JSON.parse(buf.toString("utf-8"))
+    );
+    if (packageJson === void 0) return void 0;
+    const descriptionNotParsed = packageJson[BlockDescriptionPackageJsonField];
+    if (descriptionNotParsed === void 0) return void 0;
+    const descriptionRaw = {
+      ...plModelMiddleLayer.BlockPackDescriptionFromPackageJsonRaw.parse(descriptionNotParsed),
+      id: {
+        ...parsePackageName(
+          tsHelpers.notEmpty(packageJson["name"], `"name" not found in ${fullPackageJsonPath}`)
+        ),
+        version: plModelMiddleLayer.SemVer.parse(packageJson["version"])
+      }
+    };
+    const descriptionParsingResult = await ResolvedBlockPackDescriptionFromPackageJson(moduleRoot).safeParseAsync(descriptionRaw);
+    if (descriptionParsingResult.success) return descriptionParsingResult.data;
+    return void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+async function loadPackDescriptionRaw(moduleRoot) {
+  const fullPackageJsonPath = path__default.default.resolve(moduleRoot, "package.json");
+  const packageJson = JSON.parse(await fsp2__default.default.readFile(fullPackageJsonPath, { encoding: "utf-8" }));
+  const descriptionNotParsed = packageJson[BlockDescriptionPackageJsonField];
+  if (descriptionNotParsed === void 0)
+    throw new Error(
+      `Block description (field ${BlockDescriptionPackageJsonField}) not found in ${fullPackageJsonPath}.`
+    );
+  return {
+    ...plModelMiddleLayer.BlockPackDescriptionFromPackageJsonRaw.parse(descriptionNotParsed),
+    id: {
+      ...parsePackageName(
+        tsHelpers.notEmpty(packageJson["name"], `"name" not found in ${fullPackageJsonPath}`)
+      ),
+      version: plModelMiddleLayer.SemVer.parse(packageJson["version"])
+    }
+  };
+}
+async function loadPackDescription(moduleRoot) {
+  const descriptionRaw = await loadPackDescriptionRaw(moduleRoot);
+  return await ResolvedBlockPackDescriptionFromPackageJson(moduleRoot).parseAsync(descriptionRaw);
+}
+
+exports.BlockComponentsAbsoluteUrl = BlockComponentsAbsoluteUrl;
+exports.BlockComponentsConsolidate = BlockComponentsConsolidate;
+exports.BlockComponentsDescription = BlockComponentsDescription;
+exports.BlockDescriptionPackageJsonField = BlockDescriptionPackageJsonField;
+exports.BlockPackDescriptionConsolidateToFolder = BlockPackDescriptionConsolidateToFolder;
+exports.BlockPackDescriptionManifest = BlockPackDescriptionManifest;
+exports.BlockPackManifest = BlockPackManifest;
+exports.BlockPackManifestFile = BlockPackManifestFile;
+exports.RegistryV1 = registry_v1_exports;
+exports.ResolvedBlockPackDescriptionFromPackageJson = ResolvedBlockPackDescriptionFromPackageJson;
+exports.ResolvedModuleFile = ResolvedModuleFile;
+exports.ResolvedModuleFolder = ResolvedModuleFolder;
+exports.absoluteToBase64 = absoluteToBase64;
+exports.absoluteToString = absoluteToString;
+exports.buildBlockPackDist = buildBlockPackDist;
+exports.cpAbsoluteToRelative = cpAbsoluteToRelative;
+exports.loadPackDescription = loadPackDescription;
+exports.loadPackDescriptionRaw = loadPackDescriptionRaw;
+exports.mapLocalToAbsolute = mapLocalToAbsolute;
+exports.mapRemoteToAbsolute = mapRemoteToAbsolute;
+exports.packFolderToRelativeTgz = packFolderToRelativeTgz;
+exports.parsePackageName = parsePackageName;
+exports.tryLoadPackDescription = tryLoadPackDescription;
+//# sourceMappingURL=lib.cjs.map
+//# sourceMappingURL=lib.cjs.map