@platforma-sdk/block-tools 2.1.5 → 2.1.7

package/src/registry_v1/config.ts

@@ -0,0 +1,90 @@
+import YAML from 'yaml';
+import { tryLoadFile } from '../util';
+import {
+  PlPackageJsonConfigFile,
+  PlPackageYamlConfigFile,
+  PlRegFullPackageConfigData,
+  PlRegPackageConfigDataShard
+} from './config_schema';
+import * as os from 'node:os';
+import { BlockRegistry } from './registry';
+import { storageByUrl } from '../lib/storage';
+import { FullBlockPackageName } from './v1_repo_schema';
+import { MiLogger } from '@milaboratories/ts-helpers';
+
+function mergeConfigs(
+  c1: PlRegPackageConfigDataShard,
+  c2: PlRegPackageConfigDataShard | undefined
+): PlRegPackageConfigDataShard {
+  if (c2 === undefined) return c1;
+  return {
+    ...c1,
+    ...c2,
+    registries: { ...c1.registries, ...c2.registries },
+    files: { ...c1.files, ...c2.files }
+  };
+}
+
+async function tryLoadJsonConfigFromFile(
+  file: string
+): Promise<PlRegPackageConfigDataShard | undefined> {
+  return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(JSON.parse(buf.toString())));
+}
+
+async function tryLoadYamlConfigFromFile(
+  file: string
+): Promise<PlRegPackageConfigDataShard | undefined> {
+  return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(YAML.parse(buf.toString())));
+}
+
+async function loadConfigShard(): Promise<PlRegPackageConfigDataShard> {
+  let conf = PlRegPackageConfigDataShard.parse({});
+
+  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile('./.pl.reg.json'));
+  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile('./.pl.reg.yaml'));
+  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(`${os.homedir()}/.pl.reg.json`));
+  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile(`${os.homedir()}/.pl.reg.yaml`));
+  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(PlPackageJsonConfigFile));
+  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile(PlPackageYamlConfigFile));
+
+  return conf;
+}
+
+let conf: PlRegPackageConfigDataShard | undefined = undefined;
+let confPromise: Promise<PlRegPackageConfigDataShard> | undefined = undefined;
+
+async function getConfigShard() {
+  if (conf !== undefined) return conf;
+  if (confPromise !== undefined) return await confPromise;
+  confPromise = loadConfigShard();
+  return await confPromise;
+}
+
+export class PlRegPackageConfig {
+  constructor(public readonly conf: PlRegFullPackageConfigData) {}
+
+  createRegistry(logger?: MiLogger): BlockRegistry {
+    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(): FullBlockPackageName {
+    return {
+      organization: this.conf.organization,
+      package: this.conf.package,
+      version: this.conf.version
+    };
+  }
+}
+
+export async function getConfig(finalShard: PlRegPackageConfigDataShard) {
+  const confShard = await loadConfigShard();
+  return new PlRegPackageConfig(
+    PlRegFullPackageConfigData.parse(mergeConfigs(confShard, finalShard))
+  );
+}

package/src/registry_v1/config_schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { PlRegAddress } from '../common_types';
+import { SemVer } from '@milaboratories/pl-model-middle-layer';
+
+export const PlPackageConfigData = z.object({
+  organization: z.string(),
+  package: z.string(),
+  version: SemVer.optional(),
+  files: z.record(z.string().regex(/^[^\/]+$/), z.string()).default({}),
+  meta: z.object({}).passthrough()
+});
+
+export const PlRegCommonConfigData = z.object({
+  registries: z.record(z.string(), PlRegAddress).default({}),
+  registry: z.string().optional()
+});
+export type PlRegCommonConfigData = z.infer<typeof PlRegCommonConfigData>;
+
+export const PlRegFullPackageConfigData = PlRegCommonConfigData.merge(PlPackageConfigData).required(
+  { registry: true, version: true }
+);
+export type PlRegFullPackageConfigData = z.infer<typeof PlRegFullPackageConfigData>;
+export const PlRegPackageConfigDataShard = PlRegFullPackageConfigData.partial().required({
+  registries: true,
+  files: true
+});
+export type PlRegPackageConfigDataShard = z.infer<typeof PlRegPackageConfigDataShard>;
+
+export const PlPackageJsonConfigFile = 'pl.package.json';
+export const PlPackageYamlConfigFile = 'pl.package.yaml';

package/src/registry_v1/flags.ts

@@ -0,0 +1,23 @@
+import { Flags } from '@oclif/core';
+import path from 'node:path';
+
+export interface TargetFile {
+  src: string;
+  destName: string;
+}
+
+function parseTargetFile(arg: string): TargetFile {
+  const match = arg.match(/(?<destName>[^\/\\]+)=(?<src>.*)/);
+  if (match) {
+    const { src, destName } = match.groups!;
+    return { src, destName };
+  } else {
+    return { src: arg, destName: path.basename(arg) };
+  }
+}
+
+export const targetFile = Flags.custom<TargetFile>({
+  summary: 'target files to upload',
+  helpValue: 'file_path | package_name=file_path',
+  parse: async (arg) => parseTargetFile(arg)
+});

package/src/registry_v1/index.ts

@@ -0,0 +1,3 @@
+export * from './v1_repo_schema';
+export * from './config_schema';
+export { PlRegPackageConfig } from './config';

package/src/registry_v1/registry.test.ts

@@ -0,0 +1,122 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { RegistryStorage, S3Storage, storageByUrl } from '../lib/storage';
+import fs from 'node:fs';
+import { BlockRegistry } from './registry';
+import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+
+type TestStorageInstance = {
+  storage: RegistryStorage;
+  teardown: () => Promise<void>;
+};
+type TestStorageTarget = {
+  name: string;
+  storageProvider: () => TestStorageInstance;
+};
+const testStorages: TestStorageTarget[] = [
+  {
+    name: 'local',
+    storageProvider: () => {
+      const uuid = randomUUID().toString();
+      const tmp = path.resolve('tmp');
+      const storagePath = path.resolve(tmp, uuid);
+      const storage = storageByUrl('file://' + storagePath);
+      return {
+        storage,
+        teardown: async () => {
+          await fs.promises.rm(storagePath, { recursive: true, force: true });
+        }
+      };
+    }
+  }
+];
+
+const testS3Address = process.env.TEST_S3_ADDRESS;
+if (testS3Address !== undefined) {
+  testStorages.push({
+    name: 's3',
+    storageProvider: () => {
+      const uuid = randomUUID().toString();
+      const testS3AddressURL = new URL(testS3Address!);
+      testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, '')}/${uuid}`;
+      const storage = storageByUrl(testS3AddressURL.toString());
+      return {
+        storage,
+        teardown: async () => {
+          const allFiles = await storage.listFiles('');
+          console.log('Deleting: ', allFiles);
+          await storage.deleteFiles(...allFiles);
+        }
+      };
+    }
+  });
+}
+
+test.each(testStorages)('basic registry test with $name', async ({ storageProvider }) => {
+  const { storage, teardown } = storageProvider();
+  const registry = new BlockRegistry(storage, new ConsoleLoggerAdapter());
+  await registry.updateIfNeeded();
+  const constructor1 = registry.constructNewPackage({
+    organization: 'org1',
+    package: 'pkg1',
+    version: '1.1.0'
+  });
+  await constructor1.writeMeta({ some: 'value1' });
+  await constructor1.finish();
+  await registry.updateIfNeeded();
+  const constructor2 = registry.constructNewPackage({
+    organization: 'org1',
+    package: 'pkg1',
+    version: '1.2.0'
+  });
+  await constructor2.writeMeta({ some: 'value2' });
+  await constructor2.finish();
+  await registry.updateIfNeeded();
+  expect(await registry.getPackageOverview({ organization: 'org1', package: 'pkg1' })).toEqual([
+    { version: '1.2.0', meta: { some: 'value2' } },
+    { version: '1.1.0', meta: { some: 'value1' } }
+  ]);
+  expect(await registry.getGlobalOverview()).toEqual([
+    {
+      organization: 'org1',
+      package: 'pkg1',
+      allVersions: ['1.1.0', '1.2.0'],
+      latestVersion: '1.2.0',
+      latestMeta: { some: 'value2' }
+    }
+  ]);
+  await teardown();
+});
+
+test.each(testStorages)('package modification test with $name', async ({ storageProvider }) => {
+  const { storage, teardown } = storageProvider();
+  const registry = new BlockRegistry(storage, new ConsoleLoggerAdapter());
+  const constructor1 = registry.constructNewPackage({
+    organization: 'org1',
+    package: 'pkg1',
+    version: '1.1.0'
+  });
+  await constructor1.writeMeta({ some: 'value1' });
+  await constructor1.finish();
+  const constructor2 = registry.constructNewPackage({
+    organization: 'org1',
+    package: 'pkg1',
+    version: '1.1.0'
+  });
+  await constructor2.writeMeta({ some: 'value2' });
+  await constructor2.finish();
+  await registry.updateIfNeeded();
+  expect(await registry.getPackageOverview({ organization: 'org1', package: 'pkg1' })).toEqual([
+    { version: '1.1.0', meta: { some: 'value2' } }
+  ]);
+  expect(await registry.getGlobalOverview()).toEqual([
+    {
+      organization: 'org1',
+      package: 'pkg1',
+      allVersions: ['1.1.0'],
+      latestVersion: '1.1.0',
+      latestMeta: { some: 'value2' }
+    }
+  ]);
+  await teardown();
+});

package/src/registry_v1/registry.ts

@@ -0,0 +1,253 @@
+import { RegistryStorage } from '../lib/storage';
+import { randomUUID } from 'node:crypto';
+import semver from 'semver/preload';
+import {
+  BlockPackageNameWithoutVersion,
+  FullBlockPackageName,
+  GlobalOverview,
+  GlobalOverviewPath,
+  MetaFile,
+  PackageOverview,
+  packageOverviewPath,
+  payloadFilePath
+} from './v1_repo_schema';
+import { MiLogger } from '@milaboratories/ts-helpers';
+
+function fullNameToPath(name: FullBlockPackageName): string {
+  return `${name.organization}/${name.package}/${name.version}`;
+}
+
+const VersionUpdatesPrefix = '_updates_v1/per_package_version/';
+
+function packageUpdatePath(bp: FullBlockPackageName, seed: string): string {
+  return `${VersionUpdatesPrefix}${bp.organization}/${bp.package}/${bp.version}/${seed}`;
+}
+
+const PackageUpdatePattern =
+  /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<pkg>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/;
+
+const GlobalUpdateSeedInFile = '_updates_v1/_global_update_in';
+const GlobalUpdateSeedOutFile = '_updates_v1/_global_update_out';
+
+/*
+  Note on convergence guarantee.
+
+  Here is what S3 guarantees:
+
+      Amazon S3 delivers strong read-after-write consistency automatically,
+      without changes to performance or availability, without sacrificing
+      regional isolation for applications, and at no additional cost.
+
+      After a successful write of a new object or an overwrite of an existing
+      object, any subsequent read request immediately receives the latest
+      version of the object. S3 also provides strong consistency for list
+      operations, so after a write, you can immediately perform a listing
+      of the objects in a bucket with any changes reflected.
+
+      https://aws.amazon.com/s3/faqs/#What_data_consistency_model_does_Amazon_S3_employ
+
+  The following registry update schema with _update_seed / _updated_seed
+  seems to guarantee eventual convergence of registry state, though I don't
+  have enough time to really think it through, beware.
+
+ */
+
+/**
+ * Layout:
+ *
+ *   _updates_v1/per_package/
+ *     organisationA/package1/1.2.3/seedABC    <-- Tells that change happened for organisationA/package1 version 1.2.3, and reassembly of package1 overview is required
+ *     organisationA/package1/1.2.3/seedCDE
+ *     organisationB/package2/1.4.3/seedFGH
+ *
+ *   _updates_v1/_global_update_in             <-- Anybody who changes contents writes a random seed in this file
+ *   _updates_v1/_global_update_out            <-- Update process writes update seed from the _global_update_in here after successful update.
+ *                                                 Mismatch between contents of those files is a sign that another update should be performed.
+ *
+ *   v1/                                       <-- Actual block packages content
+ *     organisationA/package2/1.2.3/meta.json
+ *     organisationA/package2/1.2.3/main.template.plj.gz
+ *     organisationA/package2/1.2.3/...
+ *     organisationA/package2/overview.json    <-- Per-package aggregated meta-data over all available versions
+ *     ...
+ *
+ *   v1/overview.json                          <-- aggregated information about all packages
+ *
+ */
+export class BlockRegistry {
+  constructor(
+    private readonly storage: RegistryStorage,
+    private readonly logger?: MiLogger
+  ) {}
+
+  constructNewPackage(pack: FullBlockPackageName): BlockRegistryPackConstructor {
+    return new BlockRegistryPackConstructor(this.storage, pack);
+  }
+
+  private async updateRegistry() {
+    this.logger?.info('Initiating registry refresh...');
+
+    // reading update requests
+    const packagesToUpdate = new Map<string, PackageUpdateInfo>();
+    const seedPaths: string[] = [];
+    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);
+      let added = false;
+      if (!update) {
+        packagesToUpdate.set(packageKeyWithoutVersion, {
+          package: { organization, package: pkg },
+          versions: new Set([version])
+        });
+        added = true;
+      } else if (!update.versions.has(version)) {
+        update.versions.add(version);
+        added = true;
+      }
+      this.logger?.info(`  - ${organization}:${pkg}:${version}`);
+    }
+
+    // loading global overview
+    const overviewContent = await this.storage.getFile(GlobalOverviewPath);
+    let overview =
+      overviewContent === undefined
+        ? []
+        : (JSON.parse(overviewContent.toString()) as GlobalOverview);
+    this.logger?.info(`Global overview loaded, ${overview.length} records`);
+
+    // updating packages
+    for (const [, packageInfo] of packagesToUpdate.entries()) {
+      // reading existing overview
+      const overviewFile = packageOverviewPath(packageInfo.package);
+      const pOverviewContent = await this.storage.getFile(overviewFile);
+      let packageOverview =
+        pOverviewContent === undefined
+          ? []
+          : (JSON.parse(pOverviewContent.toString()) as PackageOverview);
+      this.logger?.info(
+        `Updating ${packageInfo.package.organization}:${packageInfo.package.package} overview, ${packageOverview.length} records`
+      );
+
+      // removing versions that we will update
+      packageOverview = packageOverview.filter((e) => !packageInfo.versions.has(e.version));
+
+      // reading new entries
+      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()) });
+      }
+
+      // sorting entries according to version
+      packageOverview.sort((e1, e2) => semver.compare(e2.version, e1.version));
+
+      // write package overview back
+      await this.storage.putFile(overviewFile, Buffer.from(JSON.stringify(packageOverview)));
+      this.logger?.info(`Done (${packageOverview.length} records)`);
+
+      // patching corresponding entry in overview
+      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
+      });
+    }
+
+    // writing global overview
+    await this.storage.putFile(GlobalOverviewPath, Buffer.from(JSON.stringify(overview)));
+    this.logger?.info(`Global overview updated (${overview.length} records)`);
+
+    // deleting seeds
+    await this.storage.deleteFiles(...seedPaths.map((sp) => `${VersionUpdatesPrefix}${sp}`));
+    this.logger?.info(`Version update requests cleared`);
+  }
+
+  async updateIfNeeded(force: boolean = false): Promise<void> {
+    // implementation of main convergence algorithm
+
+    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 === undefined && currentUpdatedSeed === undefined) return;
+    if (
+      !force &&
+      updateRequestSeed !== undefined &&
+      currentUpdatedSeed !== undefined &&
+      updateRequestSeed.equals(currentUpdatedSeed)
+    )
+      return;
+
+    await this.updateRegistry();
+
+    if (updateRequestSeed) {
+      await this.storage.putFile(GlobalUpdateSeedOutFile, updateRequestSeed);
+      this.logger?.info(`Refresh finished`);
+    }
+  }
+
+  async getPackageOverview(
+    name: BlockPackageNameWithoutVersion
+  ): Promise<undefined | PackageOverview> {
+    const content = await this.storage.getFile(packageOverviewPath(name));
+    if (content === undefined) return undefined;
+    return JSON.parse(content.toString()) as PackageOverview;
+  }
+
+  async getGlobalOverview(): Promise<undefined | GlobalOverview> {
+    const content = await this.storage.getFile(GlobalOverviewPath);
+    if (content === undefined) return undefined;
+    return JSON.parse(content.toString()) as GlobalOverview;
+  }
+}
+
+export class BlockRegistryPackConstructor {
+  private metaAdded: boolean = false;
+  public readonly seed = randomUUID();
+
+  constructor(
+    private readonly storage: RegistryStorage,
+    public readonly name: FullBlockPackageName
+  ) {}
+
+  async addFile(file: string, content: Buffer): Promise<void> {
+    await this.storage.putFile(payloadFilePath(this.name, file), content);
+  }
+
+  async writeMeta(meta: object) {
+    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));
+  }
+}
+
+interface PackageUpdateInfo {
+  package: BlockPackageNameWithoutVersion;
+  versions: Set<String>;
+}

package/src/registry_v1/v1_repo_schema.ts

@@ -0,0 +1,42 @@
+export interface FullBlockPackageName {
+  organization: string;
+  package: string;
+  version: string;
+}
+
+const MainPrefix = 'v1/';
+
+export function packageContentPrefix(bp: FullBlockPackageName): string {
+  return `${MainPrefix}${bp.organization}/${bp.package}/${bp.version}`;
+}
+
+export function payloadFilePath(bp: FullBlockPackageName, file: string): string {
+  return `${MainPrefix}${bp.organization}/${bp.package}/${bp.version}/${file}`;
+}
+
+export type BlockPackageNameWithoutVersion = Pick<FullBlockPackageName, 'organization' | 'package'>;
+
+export function packageOverviewPath(bp: BlockPackageNameWithoutVersion): string {
+  return `${MainPrefix}${bp.organization}/${bp.package}/overview.json`;
+}
+
+export const GlobalOverviewPath = `${MainPrefix}overview.json`;
+
+export const MetaFile = 'meta.json';
+
+export interface PackageOverviewEntry {
+  version: string;
+  meta: object;
+}
+
+export type PackageOverview = PackageOverviewEntry[];
+
+export interface GlobalOverviewEntry {
+  organization: string;
+  package: string;
+  allVersions: string[];
+  latestVersion: string;
+  latestMeta: object;
+}
+
+export type GlobalOverview = GlobalOverviewEntry[];

package/src/util.ts

@@ -0,0 +1,25 @@
+import { BigIntStats } from 'node:fs';
+import fsp from 'node:fs/promises';
+
+export async function tryLoadFile<T>(
+  file: string,
+  map: (buf: Buffer) => T
+): Promise<T | undefined> {
+  try {
+    return map(await fsp.readFile(file));
+  } catch (err: any) {
+    if (err.code == 'ENOENT') return undefined;
+    else throw new Error('', { cause: err });
+  }
+}
+
+export async function tryStat(path: string): Promise<BigIntStats | undefined> {
+  try {
+    return await fsp.stat(path, { bigint: true });
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      return undefined;
+    }
+    throw error;
+  }
+}

package/src/v2/build_dist.test.ts

@@ -0,0 +1,16 @@
+import { randomUUID } from 'crypto';
+import { loadPackDescription } from './source_package';
+import path from 'path';
+import fsp from 'node:fs/promises';
+import { buildBlockPackDist } from './build_dist';
+
+test.skip('create dist test', async () => {
+  const description = await loadPackDescription(
+    '/Volumes/Data/Projects/MiLaboratory/blocks-beta/block-template'
+  );
+  console.dir(description, { depth: 5 });
+  const uuid = randomUUID();
+  const distPath = path.resolve('tmp', uuid);
+  const manifest = await buildBlockPackDist(description, distPath);
+  console.dir(manifest, { depth: 5 });
+});

package/src/v2/build_dist.ts

@@ -0,0 +1,29 @@
+import {
+  BlockPackDescriptionAbsolute,
+  BlockPackDescriptionConsolidateToFolder,
+  BlockPackDescriptionManifest,
+  BlockPackManifest,
+  BlockPackManifestFile
+} from './model';
+import fsp from 'node:fs/promises';
+import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './model/meta';
+import { patch } from 'semver';
+import path from 'node:path';
+
+export async function buildBlockPackDist(
+  description: BlockPackDescriptionAbsolute,
+  dst: string
+): Promise<BlockPackManifest> {
+  await fsp.mkdir(dst, { recursive: true });
+  const files: string[] = [];
+  const descriptionRelative = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(
+    description
+  );
+  const manifest: BlockPackManifest = BlockPackManifest.parse({
+    schema: 'v1',
+    ...descriptionRelative,
+    files
+  });
+  await fsp.writeFile(path.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
+  return manifest;
+}

package/src/v2/index.ts

@@ -0,0 +1,3 @@
+export * from './model';
+export * from './build_dist';
+export * from './source_package';

package/src/v2/model/block_components.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import {
+  ResolvedModuleFile,
+  ResolvedModuleFolder,
+  packFolderToRelativeTgz,
+  cpAbsoluteToRelative,
+  mapRemoteToAbsolute,
+} from './content_conversion';
+import { BlockComponents, BlockComponentsManifest, ContentAbsoluteBinaryLocal, ContentAbsoluteFolder, ContentRelativeBinary } from '@milaboratories/pl-model-middle-layer';
+
+export function BlockComponentsDescription(moduleRoot: string) {
+  return BlockComponents(
+    ResolvedModuleFile(moduleRoot),
+    ResolvedModuleFolder(moduleRoot, 'index.html')
+  );
+}
+export type BlockComponentsDescription = z.infer<ReturnType<typeof BlockComponentsDescription>>;
+
+export function BlockComponentsConsolidate(dstFolder: string, fileAccumulator?: string[]) {
+  return BlockComponents(
+    ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
+    ContentAbsoluteFolder.transform(packFolderToRelativeTgz(dstFolder, 'ui.tgz', fileAccumulator))
+  ).pipe(BlockComponentsManifest);
+}
+
+export function BlockComponentsAbsoluteUrl(prefix: string) {
+  return BlockComponents(
+    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
+    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
+  );
+}
+export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;

package/src/v2/model/common.ts

@@ -0,0 +1,2 @@
+export type ContextType = 'local' | 'remote';
+export type ContentType = 'text' | 'binary';