@milaboratories/pl-model-middle-layer 1.2.20 → 1.4.0

package/src/block_meta/{meta.ts → block_meta.ts}

@@ -1,12 +1,7 @@
 import { z } from 'zod';
 import {
-  ContentAbsoluteBinaryLocal,
-  ContentAbsoluteTextLocal,
   ContentExplicitBase64,
-  ContentExplicitString,
-  ContentRelative,
-  ContentRelativeBinary,
-  ContentRelativeText,
+  ContentExplicitBytes,
   DescriptionContentBinary,
   DescriptionContentText
 } from './content_types';
@@ -40,15 +35,15 @@ export const BlockPackMetaDescriptionRaw = BlockPackMeta(
 export type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;
 
 // prettier-ignore
-export const BlockPackMetaManifest = BlockPackMeta(
-  ContentRelativeText,
-  ContentRelativeBinary
+export const BlockPackMetaEmbeddedBase64 = BlockPackMeta(
+  z.string(),
+  ContentExplicitBase64
 );
-export type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;
+export type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;
 
 // prettier-ignore
-export const BlockPackMetaEmbeddedContent = BlockPackMeta(
+export const BlockPackMetaEmbeddedBytes = BlockPackMeta(
   z.string(),
-  ContentExplicitBase64
+  ContentExplicitBytes
 );
-export type BlockPackMetaEmbeddedContent = z.infer<typeof BlockPackMetaEmbeddedContent>;
+export type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;

package/src/block_meta/content_conversion.ts

@@ -1,13 +1,33 @@
-import { ContentAbsoluteUrl, ContentAnyLocal, ContentRelative } from "./content_types";
+import {
+  ContentAbsoluteUrl,
+  ContentAnyLocal,
+  ContentExplicitOrRelative,
+  ContentRelative
+} from './content_types';
 
 export function mapRemoteToAbsolute(
   rootUrl: string
-): <T extends ContentAnyLocal>(
-  value: T
-) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {
+): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {
   const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;
   return <T extends ContentAnyLocal>(value: T) =>
     value.type === 'relative'
       ? { type: 'absolute-url', url: rootWithSlash + value.path }
       : (value as Exclude<T, ContentRelative>);
 }
+
+/**
+ * Creates transformer of relative content paths, that adds a specific prefix to the relative path.
+ *
+ * If prefix = "nested-path/", paths like "somefile.txt" will be transformed to "nested-path/somefile.txt".
+ *
+ * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed
+ */
+export function addPrefixToRelative(
+  prefix: string
+): <T extends ContentExplicitOrRelative>(value: T) => T {
+  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;
+  return <T extends ContentExplicitOrRelative>(value: T) =>
+    (value.type === 'relative'
+      ? { type: 'relative', path: prefixWithSlash + value.path }
+      : value) as T;
+}

package/src/block_meta/content_types.ts

@@ -56,13 +56,17 @@ export type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;
 // Special content types
 //
 
-export const ContentExplicit = z
+export const ContentExplicitBytes = z
   .object({
-    type: z.literal('explicit'),
+    type: z.literal('explicit-bytes'),
+    mimeType: z
+      .string()
+      .regex(/\w+\/[-+.\w]+/)
+      .describe('MIME type to interpret content'),
     content: z.instanceof(Uint8Array).describe('Raw content')
   })
   .strict();
-export type ContentExplicit = z.infer<typeof ContentExplicit>;
+export type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;
 
 export const ContentAbsoluteFolder = z
   .object({
@@ -88,6 +92,13 @@ export const ContentAny = z.discriminatedUnion('type', [
 ]);
 export type ContentAny = z.infer<typeof ContentAny>;
 
+export const ContentExplicitOrRelative = z.discriminatedUnion('type', [
+  ContentExplicitString,
+  ContentExplicitBase64,
+  ContentRelative
+]);
+export type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;
+
 export const ContentAnyLocal = z.discriminatedUnion('type', [
   ContentExplicitString,
   ContentExplicitBase64,

package/src/block_meta/index.ts

@@ -1,57 +1,11 @@
-import { ZodTypeAny, string, z } from 'zod';
-import { BlockComponentsDescriptionRaw, BlockComponentsManifest } from './block_components';
-import { BlockPackId } from './block_pack_id';
-import { BlockPackMetaDescriptionRaw, BlockPackMetaManifest } from './meta';
-
-export * from './block_components';
-export * from './block_pack_id';
 export * from './common';
 export * from './content_types';
-export * from './meta';
 export * from './semver';
 
-export const BlockPackDescriptionFromPackageJsonRaw = z.object({
-  components: BlockComponentsDescriptionRaw,
-  meta: BlockPackMetaDescriptionRaw
-});
-
-export function CreateBlockPackDescriptionSchema<
-  Components extends ZodTypeAny,
-  Meta extends ZodTypeAny
->(components: Components, meta: Meta) {
-  return z.object({
-    id: BlockPackId,
-    components,
-    meta
-  });
-}
-
-export const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(
-  BlockComponentsManifest,
-  BlockPackMetaManifest
-);
-export type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;
+export * from './content_conversion';
 
-export const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(
-  BlockComponentsDescriptionRaw,
-  BlockPackMetaDescriptionRaw
-);
-export type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;
-
-export const ManifestFileInfo = z.object({
-  name: z.string(),
-  size: z.number().int(),
-  sha256: z
-    .string()
-    .regex(/[0-9a-fA-F]/)
-    .toUpperCase()
-    .length(64) // 256 / 4 (bits per hex register)
-});
-export type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;
-
-export const BlockPackManifest = z.object({
-  schema: z.literal('v1'),
-  description: BlockPackDescriptionManifest,
-  files: z.array(ManifestFileInfo)
-});
-export type BlockPackManifest = z.infer<typeof BlockPackManifest>;
+export * from './block_id';
+export * from './block_components';
+export * from './block_meta';
+export * from './block_description';
+export * from './block_manifest';

package/src/block_registry/block_pack_spec.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { BlockPackId } from '../block_meta';
+
+/** Block pack from local folder, to be used during block development. Old layout.
+ * @deprecated don't use */
+export const BlockPackDevV1 = z.object({
+  type: z.literal('dev-v1'),
+  folder: z.string(),
+  mtime: z.string().optional()
+});
+/** @deprecated don't use */
+export type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;
+
+/** Block pack from local folder, to be used during block development. New layout. */
+export const BlockPackDevV2 = z.object({
+  type: z.literal('dev-v2'),
+  folder: z.string(),
+  mtime: z.string().optional()
+});
+export type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;
+
+/**
+ * Block pack from registry with version 2 layout, to be loaded directly
+ * from the client.
+ * @deprecated don't use
+ * */
+export const BlockPackFromRegistryV1 = z.object({
+  type: z.literal('from-registry-v1'),
+  registryUrl: z.string(),
+  id: BlockPackId
+});
+/** @deprecated don't use */
+export type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;
+
+/** Block pack from registry with version 2 layout, to be loaded directly
+ * from the client. */
+export const BlockPackFromRegistryV2 = z.object({
+  type: z.literal('from-registry-v2'),
+  registryUrl: z.string(),
+  id: BlockPackId
+});
+export type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;
+
+/** Information about block origin, can be used to instantiate new blocks */
+export const BlockPackSpec = z.discriminatedUnion('type', [
+  BlockPackDevV1,
+  BlockPackDevV2,
+  BlockPackFromRegistryV1,
+  BlockPackFromRegistryV2
+]);
+export type BlockPackSpec = z.infer<typeof BlockPackSpec>;

package/src/block_registry/index.ts

@@ -0,0 +1,3 @@
+export * from './block_pack_spec';
+export * from './overview';
+export * from './registry_spec';

package/src/block_registry/overview.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';
+import { BlockPackSpec } from './block_pack_spec';
+import { RegistryEntry } from './registry_spec';
+
+/**
+ * Latest information about specific block pack. Contain information about latest version of the package.
+ * */
+export const BlockPackOverview = z.object({
+  registryId: z.string(),
+  id: BlockPackId,
+  meta: BlockPackMetaEmbeddedBytes,
+  spec: BlockPackSpec,
+  otherVersions: z.array(SemVer)
+});
+export type BlockPackOverview = z.infer<typeof BlockPackOverview>;
+
+export const RegistryStatus = RegistryEntry.extend({
+  status: z.union([z.literal('online'), z.literal('offline')])
+});
+export type RegistryStatus = z.infer<typeof RegistryStatus>;
+
+export const BlockPackListing = z.object({
+  registries: z.array(RegistryStatus),
+  blockPacks: z.array(BlockPackOverview)
+});
+export type BlockPackListing = z.infer<typeof BlockPackListing>;

package/src/block_registry/registry_spec.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+export const LocalDevFolder = z.object({
+  type: z.literal('local-dev'),
+  path: z.string()
+});
+export type LocalDevFolder = z.infer<typeof LocalDevFolder>;
+
+/** @deprecated don't use */
+export const RemoteRegistryV1Spec = z.object({
+  type: z.literal('remote-v1'),
+  url: z.string().url()
+});
+/** @deprecated don't use */
+export type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;
+
+export const RemoteRegistryV2Spec = z.object({
+  type: z.literal('remote-v2'),
+  url: z.string().url()
+});
+export type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;
+
+export const RegistrySpec = z.discriminatedUnion('type', [
+  RemoteRegistryV1Spec,
+  RemoteRegistryV2Spec,
+  LocalDevFolder
+]);
+export type RegistrySpec = z.infer<typeof RegistrySpec>;
+
+export const RegistryEntry = z.object({
+  id: z.string(),
+  title: z.string().optional(),
+  spec: RegistrySpec
+});
+export type RegistryEntry = z.infer<typeof RegistryEntry>;
+
+export const RegistryList = z.array(RegistryEntry);
+export type RegistryList = z.infer<typeof RegistryList>;

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './author_marker';
-export * from './block_pack';
+export * from './block_registry';
 export * from './block_state';
 export * from './block_meta';
 export * from './project';

package/src/project_overview.ts

@@ -1,5 +1,5 @@
 import { ProjectMeta } from './project';
-import { BlockPackSpec } from './block_pack';
+import { BlockPackSpec } from './block_registry/block_pack_spec';
 import { BlockRenderingMode, BlockSection, NavigationState } from '@milaboratories/pl-model-common';
 import { AuthorMarker } from './author_marker';
 

package/dist/block_meta/block_pack_id.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_pack_id.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_pack_id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,qCAAqC;AACrC,eAAO,MAAM,WAAW;;;;;;;;;;;;EAMb,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;;;;;;;;EAAsC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/block_meta/meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/block_meta/meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,wBAAgB,aAAa,CAC3B,KAAK,CAAC,cAAc,SAAS,CAAC,CAAC,UAAU,EACzC,KAAK,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EACrC,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgB/C;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAG1E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/block_pack.d.ts

@@ -1,24 +0,0 @@
-/** Block pack from local folder, to be used during block development. Legacy layout. */
-export interface BlockPackDevV1 {
-    type: 'dev' | 'dev-v1';
-    folder: string;
-    mtime?: string;
-}
-/** Block pack from local folder, to be used during block development. New layout. */
-export interface BlockPackDevV2 {
-    type: 'dev-v2';
-    folder: string;
-    mtime?: string;
-}
-/** Block pack from registry with version 1 layout, to be loaded directly
- * from the client. */
-export interface BlockPackFromRegistryV1 {
-    type: 'from-registry-v1';
-    registryUrl: string;
-    organization: string;
-    package: string;
-    version: string;
-}
-/** Information about block origin, can be used to instantiate new blocks */
-export type BlockPackSpec = BlockPackDevV1 | BlockPackDevV2 | BlockPackFromRegistryV1;
-//# sourceMappingURL=block_pack.d.ts.map

package/dist/block_pack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_pack.d.ts","sourceRoot":"","sources":["../src/block_pack.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,KAAK,GAAG,QAAQ,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;sBACsB;AACtB,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,kBAAkB,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,cAAc,GACd,uBAAuB,CAAC"}

package/src/block_pack.ts

@@ -1,29 +0,0 @@
-/** Block pack from local folder, to be used during block development. Legacy layout. */
-export interface BlockPackDevV1 {
-  type: 'dev' | 'dev-v1';
-  folder: string;
-  mtime?: string;
-}
-
-/** Block pack from local folder, to be used during block development. New layout. */
-export interface BlockPackDevV2 {
-  type: 'dev-v2';
-  folder: string;
-  mtime?: string;
-}
-
-/** Block pack from registry with version 1 layout, to be loaded directly
- * from the client. */
-export interface BlockPackFromRegistryV1 {
-  type: 'from-registry-v1';
-  registryUrl: string;
-  organization: string;
-  package: string;
-  version: string;
-}
-
-/** Information about block origin, can be used to instantiate new blocks */
-export type BlockPackSpec =
-  | BlockPackDevV1
-  | BlockPackDevV2
-  | BlockPackFromRegistryV1;