@platforma-sdk/block-tools 2.6.27 → 2.6.29

package/src/registry_v1/registry.ts

@@ -1,18 +1,20 @@
-import { RegistryStorage } from '../io/storage';
+import type { RegistryStorage } from '../io/storage';
 import { randomUUID } from 'node:crypto';
-import semver from 'semver';
-import {
+import * as semver from 'semver';
+import type {
   BlockPackageNameWithoutVersion,
   FullBlockPackageName,
   GlobalOverview,
+  PackageOverview } from './v1_repo_schema';
+import {
   GlobalOverviewPath,
   MetaFile,
-  PackageOverview,
   packageOverviewPath,
-  payloadFilePath
+  payloadFilePath,
 } from './v1_repo_schema';
-import { MiLogger } from '@milaboratories/ts-helpers';
+import type { MiLogger } from '@milaboratories/ts-helpers';
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function fullNameToPath(name: FullBlockPackageName): string {
   return `${name.organization}/${name.package}/${name.version}`;
 }
@@ -23,8 +25,8 @@ function packageUpdatePath(bp: FullBlockPackageName, seed: string): string {
   return `${VersionUpdatesPrefix}${bp.organization}/${bp.package}/${bp.version}/${seed}`;
 }
 
-const PackageUpdatePattern =
-  /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<pkg>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/;
+const PackageUpdatePattern
+  = /(?<packageKeyWithoutVersion>(?<organization>[^/]+)\/(?<pkg>[^/]+))\/(?<version>[^/]+)\/(?<seed>[^/]+)$/;
 
 const GlobalUpdateSeedInFile = '_updates_v1/_global_update_in';
 const GlobalUpdateSeedOutFile = '_updates_v1/_global_update_out';
@@ -77,14 +79,14 @@ const GlobalUpdateSeedOutFile = '_updates_v1/_global_update_out';
 export class BlockRegistry {
   constructor(
     private readonly storage: RegistryStorage,
-    private readonly logger?: MiLogger
+    private readonly logger?: MiLogger,
   ) {}
 
   constructNewPackage(pack: FullBlockPackageName): BlockRegistryPackConstructor {
     return new BlockRegistryPackConstructor(this.storage, pack);
   }
 
-  private async updateRegistry() {
+  private async updateRegistry(): Promise<void> {
     this.logger?.info('Initiating registry refresh...');
 
     // reading update requests
@@ -96,27 +98,24 @@ export class BlockRegistry {
       const match = seedPath.match(PackageUpdatePattern);
       if (!match) continue;
       seedPaths.push(seedPath);
-      const { packageKeyWithoutVersion, organization, pkg, version, seed } = match.groups!;
+      const { packageKeyWithoutVersion, organization, pkg, version, seed: _seed } = match.groups!;
 
-      let update = packagesToUpdate.get(packageKeyWithoutVersion);
-      let added = false;
+      const update = packagesToUpdate.get(packageKeyWithoutVersion);
       if (!update) {
         packagesToUpdate.set(packageKeyWithoutVersion, {
           package: { organization, package: pkg },
-          versions: new Set([version])
+          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
+    let overview: GlobalOverview
+      = overviewContent === undefined
         ? []
         : (JSON.parse(overviewContent.toString()) as GlobalOverview);
     this.logger?.info(`Global overview loaded, ${overview.length} records`);
@@ -126,12 +125,12 @@ export class BlockRegistry {
       // reading existing overview
       const overviewFile = packageOverviewPath(packageInfo.package);
       const pOverviewContent = await this.storage.getFile(overviewFile);
-      let packageOverview =
-        pOverviewContent === undefined
+      let packageOverview
+        = pOverviewContent === undefined
           ? []
           : (JSON.parse(pOverviewContent.toString()) as PackageOverview);
       this.logger?.info(
-        `Updating ${packageInfo.package.organization}:${packageInfo.package.package} overview, ${packageOverview.length} records`
+        `Updating ${packageInfo.package.organization}:${packageInfo.package.package} overview, ${packageOverview.length} records`,
       );
 
       // removing versions that we will update
@@ -144,13 +143,13 @@ export class BlockRegistry {
           payloadFilePath(
             {
               ...packageInfo.package,
-              version
+              version,
             },
-            MetaFile
-          )
+            MetaFile,
+          ),
         );
         if (!metaContent) continue;
-        packageOverview.push({ version, meta: JSON.parse(metaContent.toString()) });
+        packageOverview.push({ version, meta: JSON.parse(metaContent.toString()) as Record<string, unknown> });
       }
 
       // sorting entries according to version
@@ -163,15 +162,15 @@ export class BlockRegistry {
       // patching corresponding entry in overview
       overview = overview.filter(
         (e) =>
-          e.organization !== packageInfo.package.organization ||
-          e.package !== packageInfo.package.package
+          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
+        latestMeta: packageOverview[0].meta,
       });
     }
 
@@ -192,10 +191,10 @@ export class BlockRegistry {
     const currentUpdatedSeed = await this.storage.getFile(GlobalUpdateSeedOutFile);
     if (!force && updateRequestSeed === undefined && currentUpdatedSeed === undefined) return;
     if (
-      !force &&
-      updateRequestSeed !== undefined &&
-      currentUpdatedSeed !== undefined &&
-      updateRequestSeed.equals(currentUpdatedSeed)
+      !force
+      && updateRequestSeed !== undefined
+      && currentUpdatedSeed !== undefined
+      && updateRequestSeed.equals(currentUpdatedSeed)
     )
       return;
 
@@ -208,7 +207,7 @@ export class BlockRegistry {
   }
 
   async getPackageOverview(
-    name: BlockPackageNameWithoutVersion
+    name: BlockPackageNameWithoutVersion,
   ): Promise<undefined | PackageOverview> {
     const content = await this.storage.getFile(packageOverviewPath(name));
     if (content === undefined) return undefined;
@@ -228,7 +227,7 @@ export class BlockRegistryPackConstructor {
 
   constructor(
     private readonly storage: RegistryStorage,
-    public readonly name: FullBlockPackageName
+    public readonly name: FullBlockPackageName,
   ) {}
 
   async addFile(file: string, content: Buffer): Promise<void> {
@@ -249,5 +248,5 @@ export class BlockRegistryPackConstructor {
 
 interface PackageUpdateInfo {
   package: BlockPackageNameWithoutVersion;
-  versions: Set<String>;
+  versions: Set<string>;
 }

package/src/registry_v1/v1_repo_schema.ts

@@ -26,7 +26,7 @@ export const MetaFile = 'meta.json';
 
 export interface PackageOverviewEntry {
   version: string;
-  meta: object;
+  meta: Record<string, unknown>;
 }
 
 export type PackageOverview = PackageOverviewEntry[];
@@ -36,7 +36,7 @@ export interface GlobalOverviewEntry {
   package: string;
   allVersions: string[];
   latestVersion: string;
-  latestMeta: any;
+  latestMeta: Record<string, unknown>;
 }
 
 export type GlobalOverview = GlobalOverviewEntry[];

package/src/util.ts

@@ -1,31 +1,35 @@
-import { BigIntStats } from 'node:fs';
+import type { BigIntStats } from 'node:fs';
 import fsp from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 
 export async function tryLoadFile<T>(
   file: string,
-  map: (buf: Buffer) => T
+  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 });
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return undefined;
+    else throw 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') {
+  } catch (error: unknown) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
       return undefined;
     }
     throw error;
   }
 }
 
-export async function calculateSha256(bytes: ArrayBuffer) {
-  return Buffer.from(await crypto.subtle.digest('sha-256', bytes))
-    .toString('hex')
-    .toUpperCase();
+export function calculateSha256(bytes: ArrayBuffer): Promise<string> {
+  return Promise.resolve(
+    createHash('sha256')
+      .update(Buffer.from(bytes))
+      .digest('hex')
+      .toUpperCase(),
+  );
 }

package/src/v2/build_dist.ts

@@ -1,37 +1,40 @@
-import {
+import type {
   BlockPackDescriptionManifest,
+  ManifestFileInfo,
+} from '@milaboratories/pl-model-middle-layer';
+import {
   BlockPackManifest,
   BlockPackManifestFile,
-  ManifestFileInfo
 } from '@milaboratories/pl-model-middle-layer';
-import { BlockPackDescriptionAbsolute, BlockPackDescriptionConsolidateToFolder } from './model';
+import type { BlockPackDescriptionAbsolute } from './model';
+import { BlockPackDescriptionConsolidateToFolder } from './model';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { calculateSha256 } from '../util';
 
 export async function buildBlockPackDist(
   description: BlockPackDescriptionAbsolute,
-  dst: string
+  dst: string,
 ): Promise<BlockPackManifest> {
   await fsp.mkdir(dst, { recursive: true });
   const files: string[] = [];
-  const descriptionRelative: BlockPackDescriptionManifest =
-    await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(description);
+  const descriptionRelative: BlockPackDescriptionManifest
+    = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(description);
   const filesForManifest = await Promise.all(
     files.map(async (f): Promise<ManifestFileInfo> => {
       const bytes = await fsp.readFile(path.resolve(dst, f));
       const sha256 = await calculateSha256(bytes);
       return { name: f, size: bytes.length, sha256 };
-    })
+    }),
   );
 
   const manifest: BlockPackManifest = BlockPackManifest.parse({
     schema: 'v2',
     description: {
-      ...descriptionRelative
+      ...descriptionRelative,
     },
     files: filesForManifest,
-    timestamp: Date.now()
+    timestamp: Date.now(),
   } satisfies BlockPackManifest);
   await fsp.writeFile(path.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
   return manifest;

package/src/v2/model/block_components.ts

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

package/src/v2/model/block_description.ts

@@ -6,25 +6,25 @@ import {
   ContentRelative,
   ContentRelativeBinary,
   ContentRelativeText,
-  CreateBlockPackDescriptionSchema
+  CreateBlockPackDescriptionSchema,
 } from '@milaboratories/pl-model-middle-layer';
 import { BlockComponentsConsolidate, BlockComponentsDescription } from './block_components';
 import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './block_meta';
-import { z } from 'zod';
-import path from 'node:path';
+import type { z } from 'zod';
 import fsp from 'node:fs/promises';
-import { BlockConfigContainer, extractConfigGeneric } from '@milaboratories/pl-model-common';
+import type { BlockConfigContainer } from '@milaboratories/pl-model-common';
+import { extractConfigGeneric } from '@milaboratories/pl-model-common';
 
 export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
   return CreateBlockPackDescriptionSchema(
     BlockComponentsDescription(root),
-    BlockPackMetaDescription(root)
-  ).transform(async (description, ctx) => {
+    BlockPackMetaDescription(root),
+  ).transform(async (description, _ctx) => {
     const cfg = extractConfigGeneric(JSON.parse(await fsp.readFile(description.components.model.file, 'utf-8')) as BlockConfigContainer);
     const featureFlags = cfg.featureFlags;
     return {
       ...description,
-      featureFlags
+      featureFlags,
     };
   });
 }
@@ -34,11 +34,11 @@ export type BlockPackDescriptionAbsolute = z.infer<
 
 export function BlockPackDescriptionConsolidateToFolder(
   dstFolder: string,
-  fileAccumulator?: string[]
+  fileAccumulator?: string[],
 ) {
   return CreateBlockPackDescriptionSchema(
     BlockComponentsConsolidate(dstFolder, fileAccumulator),
-    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
+    BlockPackMetaConsolidate(dstFolder, fileAccumulator),
   ).pipe(BlockPackDescriptionManifest);
 }
 
@@ -48,12 +48,12 @@ export function BlockPackDescriptionManifestAddRelativePathPrefix(prefix: string
     CreateBlockPackDescriptionSchema(
       BlockComponents(
         ContentRelative.transform(transformer),
-        ContentRelative.transform(transformer)
+        ContentRelative.transform(transformer),
       ),
       BlockPackMeta(
         ContentRelativeText.transform(transformer),
-        ContentRelativeBinary.transform(transformer)
-      )
-    )
+        ContentRelativeBinary.transform(transformer),
+      ),
+    ),
   ).pipe(BlockPackDescriptionManifest);
 }

package/src/v2/model/block_meta.ts

@@ -7,24 +7,25 @@ import {
   ContentRelativeBinary,
   ContentRelativeText,
   DescriptionContentBinary,
-  DescriptionContentText
+  DescriptionContentText,
 } from '@milaboratories/pl-model-middle-layer';
+import type {
+  RelativeContentReader } from './content_conversion';
 import {
   absoluteToBase64,
   absoluteToBytes,
   absoluteToString,
   cpAbsoluteToRelative,
   mapLocalToAbsolute,
-  RelativeContentReader,
   relativeToContentString,
-  relativeToExplicitBytes
+  relativeToExplicitBytes,
 } from './content_conversion';
-import { z } from 'zod';
+import type { z } from 'zod';
 
 export function BlockPackMetaDescription(root: string) {
   return BlockPackMeta(
     DescriptionContentText.transform(mapLocalToAbsolute(root)),
-    DescriptionContentBinary.transform(mapLocalToAbsolute(root))
+    DescriptionContentBinary.transform(mapLocalToAbsolute(root)),
   );
 }
 export type BlockPackMetaDescription = z.infer<ReturnType<typeof BlockPackMetaDescription>>;
@@ -32,23 +33,23 @@ export type BlockPackMetaDescription = z.infer<ReturnType<typeof BlockPackMetaDe
 export function BlockPackMetaConsolidate(dstFolder: string, fileAccumulator?: string[]) {
   return BlockPackMeta(
     ContentAbsoluteTextLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
-    ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator))
+    ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
   );
 }
 
 export const BlockPackMetaEmbedAbsoluteBase64 = BlockPackMeta(
   ContentAbsoluteTextLocal.transform(absoluteToString()),
-  ContentAbsoluteBinaryLocal.transform(absoluteToBase64())
+  ContentAbsoluteBinaryLocal.transform(absoluteToBase64()),
 ).pipe(BlockPackMetaEmbeddedBase64);
 
 export const BlockPackMetaEmbedAbsoluteBytes = BlockPackMeta(
   ContentAbsoluteTextLocal.transform(absoluteToString()),
-  ContentAbsoluteBinaryLocal.transform(absoluteToBytes())
+  ContentAbsoluteBinaryLocal.transform(absoluteToBytes()),
 ).pipe(BlockPackMetaEmbeddedBytes);
 
 export function BlockPackMetaEmbedBytes(reader: RelativeContentReader) {
   return BlockPackMeta(
     ContentRelativeText.transform(relativeToContentString(reader)),
-    ContentRelativeBinary.transform(relativeToExplicitBytes(reader))
+    ContentRelativeBinary.transform(relativeToExplicitBytes(reader)),
   ).pipe(BlockPackMetaEmbeddedBytes);
 }

package/src/v2/model/content_conversion.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import path from 'path';
+import path from 'node:path';
 import fsp from 'node:fs/promises';
 import * as mime from 'mime-types';
 import * as tar from 'tar';
-import {
+import type {
   ContentAbsoluteBinaryLocal,
   ContentAbsoluteFile,
   ContentAbsoluteFolder,
@@ -14,7 +14,7 @@ import {
   ContentExplicitString,
   ContentRelative,
   ContentRelativeBinary,
-  ContentRelativeText
+  ContentRelativeText,
 } from '@milaboratories/pl-model-middle-layer';
 import { tryResolve } from '@milaboratories/resolve-helper';
 
@@ -33,6 +33,7 @@ type ContentCtxUrl = {
 /** Describes a place relative to which any content references should be interpreted */
 export type ContentCtx = ContentCtxFs | ContentCtxUrl;
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- utility function for future use
 function mustResolve(root: string, request: string): string {
   const res = tryResolve(root, request);
   if (res === undefined) throw new Error(`Can't resolve ${request} against ${root}`);
@@ -46,13 +47,13 @@ export function ResolvedModuleFile(moduleRoot: string) {
     if (result === undefined) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
-        message: `Can't resolve ${request} against ${moduleRoot}`
+        message: `Can't resolve ${request} against ${moduleRoot}`,
       });
       return z.NEVER;
     }
     return {
       type: 'absolute-file',
-      file: result
+      file: result,
     };
   });
 }
@@ -75,21 +76,21 @@ export function ResolvedModuleFolder(
           throw new Error(`Unexpected resolve result ${result} with index file ${idxFile}`);
         return {
           type: 'absolute-folder',
-          folder: result.slice(0, result.length - idxFile.length)
+          folder: result.slice(0, result.length - idxFile.length),
         };
       }
     }
 
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
-      message: `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(', ')})`
+      message: `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(', ')})`,
     });
     return z.NEVER;
   });
 }
 
 export function mapLocalToAbsolute(
-  root: string
+  root: string,
 ): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteFile {
   return <T extends ContentAnyLocal>(value: T) =>
     value.type === 'relative'
@@ -107,7 +108,7 @@ export function absoluteToString(): (value: ContentAbsoluteTextLocal) => Promise
 
 // TODO add type and size limitations
 export function absoluteToBase64(): (
-  value: ContentAbsoluteBinaryLocal
+value: ContentAbsoluteBinaryLocal
 ) => Promise<ContentExplicitBase64> {
   return async (value) => {
     if (value.type === 'absolute-file') {
@@ -116,14 +117,14 @@ export function absoluteToBase64(): (
       return {
         type: 'explicit-base64',
         mimeType,
-        content: await fsp.readFile(value.file, { encoding: 'base64' })
+        content: await fsp.readFile(value.file, { encoding: 'base64' }),
       };
     } else return value;
   };
 }
 
 export function absoluteToBytes(): (
-  value: ContentAbsoluteBinaryLocal
+value: ContentAbsoluteBinaryLocal
 ) => Promise<ContentExplicitBytes> {
   return async (value) => {
     if (value.type === 'absolute-file') {
@@ -132,13 +133,13 @@ export function absoluteToBytes(): (
       return {
         type: 'explicit-bytes',
         mimeType,
-        content: Buffer.from(await fsp.readFile(value.file))
+        content: Buffer.from(await fsp.readFile(value.file)),
       };
     } else if (value.type === 'explicit-base64') {
       return {
         type: 'explicit-bytes',
         mimeType: value.mimeType,
-        content: Buffer.from(value.content, 'base64')
+        content: Buffer.from(value.content, 'base64'),
       };
     } else return value;
   };
@@ -146,15 +147,16 @@ export function absoluteToBytes(): (
 
 export function cpAbsoluteToRelative(
   dstFolder: string,
-  fileAccumulator?: string[]
+  fileAccumulator?: string[],
 ): <T extends Exclude<ContentAnyLocal, ContentRelative>>(
-  value: T
-) => Promise<Exclude<T, ContentAbsoluteFile> | ContentRelative> {
+    value: T
+  ) => Promise<Exclude<T, ContentAbsoluteFile> | ContentRelative> {
   return async <T extends Exclude<ContentAnyLocal, ContentRelative>>(value: T) => {
     if (value.type === 'absolute-file') {
       const fileName = path.basename(value.file);
       const dst = path.resolve(dstFolder, fileName);
       fileAccumulator?.push(fileName);
+      // eslint-disable-next-line n/no-unsupported-features/node-builtins
       await fsp.cp(value.file, dst);
       return { type: 'relative', path: fileName };
     } else return value as Exclude<T, ContentAbsoluteFile>;
@@ -164,7 +166,7 @@ export function cpAbsoluteToRelative(
 export function packFolderToRelativeTgz(
   dstFolder: string,
   tgzName: string,
-  fileAccumulator?: string[]
+  fileAccumulator?: string[],
 ): (value: ContentAbsoluteFolder) => Promise<ContentRelative> {
   if (!tgzName.endsWith('.tgz')) throw new Error(`Unexpected tgz file name: ${tgzName}`);
   return async (value: ContentAbsoluteFolder) => {
@@ -173,9 +175,9 @@ export function packFolderToRelativeTgz(
       {
         gzip: true,
         file: dst,
-        cwd: value.folder
+        cwd: value.folder,
       },
-      ['.']
+      ['.'],
     );
     fileAccumulator?.push(tgzName);
     return { type: 'relative', path: tgzName };
@@ -185,7 +187,7 @@ export function packFolderToRelativeTgz(
 export type RelativeContentReader = (relativePath: string) => Promise<Buffer>;
 
 export function relativeToExplicitString(
-  reader: RelativeContentReader
+  reader: RelativeContentReader,
 ): (value: ContentRelativeText) => Promise<ContentExplicitString> {
   return async (value) =>
     value.type === 'explicit-string'
@@ -194,14 +196,14 @@ export function relativeToExplicitString(
 }
 
 export function relativeToContentString(
-  reader: RelativeContentReader
+  reader: RelativeContentReader,
 ): (value: ContentRelativeText) => Promise<string> {
   return async (value) =>
     value.type === 'explicit-string' ? value.content : (await reader(value.path)).toString('utf8');
 }
 
 export function relativeToExplicitBinary64(
-  reader: RelativeContentReader
+  reader: RelativeContentReader,
 ): (value: ContentRelativeBinary) => Promise<ContentExplicitBase64> {
   return async (value) => {
     if (value.type === 'explicit-base64') return value;
@@ -210,27 +212,27 @@ export function relativeToExplicitBinary64(
     return {
       type: 'explicit-base64',
       mimeType,
-      content: (await reader(value.path)).toString('base64')
+      content: (await reader(value.path)).toString('base64'),
     };
   };
 }
 
 export function relativeToExplicitBytes(
-  reader: RelativeContentReader
+  reader: RelativeContentReader,
 ): (value: ContentRelativeBinary) => Promise<ContentExplicitBytes> {
   return async (value) => {
     if (value.type === 'explicit-base64')
       return {
         type: 'explicit-bytes',
         mimeType: value.mimeType,
-        content: Buffer.from(value.content, 'base64')
+        content: Buffer.from(value.content, 'base64'),
       };
     const mimeType = mime.lookup(value.path);
     if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.path}.`);
     return {
       type: 'explicit-bytes',
       mimeType,
-      content: await reader(value.path)
+      content: await reader(value.path),
     };
   };
 }

package/src/v2/registry/index.ts

@@ -1,3 +1,3 @@
-export * from './registry'
-export * from './registry_reader'
-export * from './schema_public'
+export * from './registry';
+export * from './registry_reader';
+export * from './schema_public';