@milaboratories/pl-model-middle-layer 1.7.6 → 1.7.8

package/dist/block_meta/block_description.d.ts

@@ -228,6 +228,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
             } | undefined;
         }>;
         marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+        termsOfServiceUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         organization: {
             url: string;
@@ -282,6 +283,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }, {
         organization: {
             url: string;
@@ -336,6 +338,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     components: {
@@ -400,6 +403,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
 }, {
     components: {
@@ -464,6 +468,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
 }>;
 export declare function CreateBlockPackDescriptionSchema<Components extends ZodTypeAny, Meta extends ZodTypeAny>(components: Components, meta: Meta): z.ZodObject<{
@@ -785,6 +790,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
             } | undefined;
         }>;
         marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+        termsOfServiceUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         organization: {
             url: string;
@@ -839,6 +845,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }, {
         organization: {
             url: string;
@@ -893,6 +900,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     components: {
@@ -957,6 +965,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -1026,6 +1035,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;

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

@@ -1 +1 @@
-{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAGpC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD,CAAC;AAEH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,UAAU,EAC7B,IAAI,SAAS,UAAU,EACvB,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAMnC;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,wBAAgB,0BAA0B,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,WAAW,CAAA;CAAE,EACtE,QAAQ,EAAE,CAAC,EACX,UAAU,EAAE,MAAM,GACjB,CAAC,CAEH"}
+{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAGpC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD,CAAC;AAEH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,UAAU,EAC7B,IAAI,SAAS,UAAU,EACvB,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAMnC;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,wBAAgB,0BAA0B,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,WAAW,CAAA;CAAE,EACtE,QAAQ,EAAE,CAAC,EACX,UAAU,EAAE,MAAM,GACjB,CAAC,CAEH"}

package/dist/block_meta/block_manifest.d.ts

@@ -241,6 +241,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
         } | undefined;
     }>;
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     organization: {
         url: string;
@@ -283,6 +284,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }, {
     organization: {
         url: string;
@@ -325,6 +327,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }>;
 export type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;
 /** Block description to be used in block manifest */
@@ -582,6 +585,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
             } | undefined;
         }>;
         marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+        termsOfServiceUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         organization: {
             url: string;
@@ -624,6 +628,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }, {
         organization: {
             url: string;
@@ -666,6 +671,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     components: {
@@ -727,6 +733,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -796,6 +803,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -1075,6 +1083,7 @@ export declare const BlockPackManifest: z.ZodObject<{
                 } | undefined;
             }>;
             marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+            termsOfServiceUrl: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             organization: {
                 url: string;
@@ -1117,6 +1126,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         }, {
             organization: {
                 url: string;
@@ -1159,6 +1169,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         components: {
@@ -1220,6 +1231,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1289,6 +1301,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1371,6 +1384,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1449,6 +1463,7 @@ export declare const BlockPackManifest: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;

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

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"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"}

package/dist/block_meta/block_meta.d.ts

@@ -35,6 +35,10 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, { [k_2 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     title: z.ZodString;
     description: z.ZodString;
@@ -71,6 +75,10 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     title: z.ZodString;
     description: z.ZodString;
@@ -107,6 +115,10 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }>, any>[k_2]; }, { [k_1_1 in keyof z.baseObjectInputType<{
     title: z.ZodString;
     description: z.ZodString;
@@ -143,6 +155,10 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }>]: z.baseObjectInputType<{
     title: z.ZodString;
     description: z.ZodString;
@@ -179,6 +195,10 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }>[k_1_1]; }>;
 export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
     title: z.ZodString;
@@ -368,6 +388,10 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     organization: {
         url: string;
@@ -422,6 +446,7 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }, {
     organization: {
         url: string;
@@ -476,6 +501,7 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }>;
 export type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;
 export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
@@ -538,6 +564,10 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     organization: {
         url: string;
@@ -562,6 +592,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }, {
     organization: {
         url: string;
@@ -586,6 +617,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }>;
 export type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;
 export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
@@ -648,6 +680,10 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     organization: {
         url: string;
@@ -672,6 +708,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }, {
     organization: {
         url: string;
@@ -696,6 +733,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     support?: string | undefined;
     tags?: string[] | undefined;
     marketplaceRanking?: number | undefined;
+    termsOfServiceUrl?: string | undefined;
 }>;
 export type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;
 //# sourceMappingURL=block_meta.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"block_meta.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB5C;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAHH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAHH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAHH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAHH;;;OAGG;;cAGN;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IATpC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASN,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAhBpC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBN,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAvBnC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBN,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"block_meta.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB5C;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAPH;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAPH;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAPH;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAPH;;;OAGG;;IAEH;;OAEG;;cAGN;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAbpC;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASN,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApBpC;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBN,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA3BnC;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBN,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/block_registry/overview.d.ts

@@ -73,6 +73,7 @@ export declare const BlockPackOverviewLegacy: z.ZodObject<{
             } | undefined;
         }>;
         marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+        termsOfServiceUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         organization: {
             url: string;
@@ -97,6 +98,7 @@ export declare const BlockPackOverviewLegacy: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }, {
         organization: {
             url: string;
@@ -121,6 +123,7 @@ export declare const BlockPackOverviewLegacy: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }>;
     spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"dev-v1">;
@@ -240,6 +243,7 @@ export declare const BlockPackOverviewLegacy: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -299,6 +303,7 @@ export declare const BlockPackOverviewLegacy: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -420,6 +425,7 @@ export declare const SingleBlockPackOverview: z.ZodObject<{
             } | undefined;
         }>;
         marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+        termsOfServiceUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         organization: {
             url: string;
@@ -444,6 +450,7 @@ export declare const SingleBlockPackOverview: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }, {
         organization: {
             url: string;
@@ -468,6 +475,7 @@ export declare const SingleBlockPackOverview: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     }>;
     spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"dev-v1">;
@@ -586,6 +594,7 @@ export declare const SingleBlockPackOverview: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -643,6 +652,7 @@ export declare const SingleBlockPackOverview: z.ZodObject<{
         support?: string | undefined;
         tags?: string[] | undefined;
         marketplaceRanking?: number | undefined;
+        termsOfServiceUrl?: string | undefined;
     };
     id: {
         organization: string;
@@ -762,6 +772,7 @@ export declare const BlockPackOverview: z.ZodObject<{
                 } | undefined;
             }>;
             marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+            termsOfServiceUrl: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             organization: {
                 url: string;
@@ -786,6 +797,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         }, {
             organization: {
                 url: string;
@@ -810,6 +822,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         }>;
         spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             type: z.ZodLiteral<"dev-v1">;
@@ -928,6 +941,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -985,6 +999,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1060,6 +1075,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1128,6 +1144,7 @@ export declare const BlockPackOverview: z.ZodObject<{
             support?: string | undefined;
             tags?: string[] | undefined;
             marketplaceRanking?: number | undefined;
+            termsOfServiceUrl?: string | undefined;
         };
         id: {
             organization: string;
@@ -1375,6 +1392,7 @@ export declare const BlockPackListing: z.ZodObject<{
                     } | undefined;
                 }>;
                 marketplaceRanking: z.ZodOptional<z.ZodNumber>;
+                termsOfServiceUrl: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
                 organization: {
                     url: string;
@@ -1399,6 +1417,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             }, {
                 organization: {
                     url: string;
@@ -1423,6 +1442,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             }>;
             spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                 type: z.ZodLiteral<"dev-v1">;
@@ -1541,6 +1561,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;
@@ -1598,6 +1619,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;
@@ -1673,6 +1695,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;
@@ -1741,6 +1764,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;
@@ -1826,6 +1850,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;
@@ -1911,6 +1936,7 @@ export declare const BlockPackListing: z.ZodObject<{
                 support?: string | undefined;
                 tags?: string[] | undefined;
                 marketplaceRanking?: number | undefined;
+                termsOfServiceUrl?: string | undefined;
             };
             id: {
                 organization: string;

package/dist/block_registry/overview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;KAEK;AACL,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,UAAU,QAAQ,CAAC;AAChC,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC,eAAO,MAAM,mBAAmB;;;;;;;;;EAG9B,CAAC;AAEH;;KAEK;AACL,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;KAEK;AACL,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,iBAAiB,GAAG,uBAAuB,CAazF"}

package/dist/index.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),X=require("remeda");function Y(e){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const o in e)if(o!=="default"){const l=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(n,o,l.get?l:{enumerable:!0,get:()=>e[o]})}}return n.default=e,Object.freeze(n)}const h=Y(X),tt={},c=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),r=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),i=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),R=new RegExp("^(/|[A-Z]:\\\\)"),s=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(R,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),d=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),A=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),et=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(R,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),nt=t.z.discriminatedUnion("type",[c,r,i,s,d]),ot=t.z.discriminatedUnion("type",[c,r,i]),it=t.z.discriminatedUnion("type",[c,r,i,s]),rt=t.z.discriminatedUnion("type",[c,r,i,d]),j=t.z.discriminatedUnion("type",[r,i,s]),S=t.z.discriminatedUnion("type",[c,i,s]),ct=t.z.discriminatedUnion("type",[r,d]),st=t.z.discriminatedUnion("type",[r,s]),at=t.z.discriminatedUnion("type",[c,d]),lt=t.z.discriminatedUnion("type",[c,s]),g=t.z.discriminatedUnion("type",[r,i]),w=t.z.discriminatedUnion("type",[c,i]),x=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),j]),V=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),S]),p=t.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,"Wrong version format, please use valid semver");function y(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"absolute-url",url:n+o.path}:o}function dt(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"relative",path:n+o.path}:o}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:p}).strict(),M=a.omit({version:!0});function zt(e){if(e!==void 0)return`${e.organization}:${e.name}:${e.version}`}function kt(e){if(e!==void 0)return`${e.organization}:${e.name}`}function gt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization&&e.version===n.version}function pt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization}function m(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function D(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(m(e)),t.z.discriminatedUnion("type",[m(e)])])}function u(e,n){return t.z.object({workflow:D(e),model:e,ui:n})}const f=u(t.z.string(),t.z.string());function ut(e){return u(g.transform(y(e)),g.transform(y(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()}),marketplaceRanking:t.z.number().optional()})}const b=z(V,x),yt=z(t.z.string(),r),v=z(t.z.string(),A),mt=t.z.object({components:f,meta:b});function B(e,n){return t.z.object({id:a,components:e,meta:n})}const ft=B(f,b);function bt(e,n){return h.mergeDeep(e,{id:{version:n}})}const I=u(i,i),T=z(w,g),U=B(I,T),E=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),L=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:E}),vt=t.z.object({schema:t.z.literal("v2"),description:U,timestamp:t.z.number().optional(),files:t.z.array(L)}),Bt="manifest.json";function Pt(e,n){return h.mergeDeep(e,{description:{id:{version:n}}})}const O=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),W=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),$=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a,channel:t.z.string().optional()}),P=t.z.discriminatedUnion("type",[O,F,W,$]),q=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),N=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),Z=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),_=t.z.discriminatedUnion("type",[N,Z,q]),C=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:_}),Ct=t.z.array(C),ht=t.z.object({registryId:t.z.string(),id:a,meta:v,spec:P,otherVersions:t.z.array(p)}),J="any",k="stable",G=t.z.object({version:p,channels:t.z.array(t.z.string())}),H=t.z.object({id:a,meta:v,spec:P}),K=t.z.object({id:M,latestByChannel:t.z.record(t.z.string(),H),allVersions:t.z.array(G),registryId:t.z.string()}),Q=C.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),Rt=t.z.object({registries:t.z.array(Q),blockPacks:t.z.array(K)});function At(e){const n=e.latestByChannel[k]!==void 0?k:J,o=e.latestByChannel[n];return{id:o.id,meta:o.meta,spec:{...o.spec,channel:k},otherVersions:e.allVersions.filter(l=>l.channels.indexOf(n)>=0).map(l=>l.version),registryId:e.registryId}}const jt=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.AnyChannel=J;exports.BlockComponents=u;exports.BlockComponentsAbsoluteUrl=ut;exports.BlockComponentsDescriptionRaw=f;exports.BlockComponentsManifest=I;exports.BlockPackDescriptionFromPackageJsonRaw=mt;exports.BlockPackDescriptionManifest=U;exports.BlockPackDescriptionRaw=ft;exports.BlockPackDevV1=O;exports.BlockPackDevV2=F;exports.BlockPackFromRegistryV1=W;exports.BlockPackFromRegistryV2=$;exports.BlockPackId=a;exports.BlockPackIdNoVersion=M;exports.BlockPackListing=Rt;exports.BlockPackManifest=vt;exports.BlockPackManifestFile=Bt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=b;exports.BlockPackMetaEmbeddedBase64=yt;exports.BlockPackMetaEmbeddedBytes=v;exports.BlockPackMetaManifest=T;exports.BlockPackOverview=K;exports.BlockPackOverviewLegacy=ht;exports.BlockPackSpec=P;exports.ContentAbsoluteBinaryLocal=st;exports.ContentAbsoluteBinaryRemote=ct;exports.ContentAbsoluteFile=s;exports.ContentAbsoluteFolder=et;exports.ContentAbsoluteTextLocal=lt;exports.ContentAbsoluteTextRemote=at;exports.ContentAbsoluteUrl=d;exports.ContentAny=nt;exports.ContentAnyBinaryLocal=j;exports.ContentAnyLocal=it;exports.ContentAnyRemote=rt;exports.ContentAnyTextLocal=S;exports.ContentExplicitBase64=r;exports.ContentExplicitBytes=A;exports.ContentExplicitOrRelative=ot;exports.ContentExplicitString=c;exports.ContentRelative=i;exports.ContentRelativeBinary=g;exports.ContentRelativeText=w;exports.CreateBlockPackDescriptionSchema=B;exports.DescriptionContentBinary=x;exports.DescriptionContentText=V;exports.InitialBlockSettings=tt;exports.LocalDevFolder=q;exports.ManifestFileInfo=L;exports.PFrameInternal=jt;exports.RegistryEntry=C;exports.RegistryList=Ct;exports.RegistrySpec=_;exports.RegistryStatus=Q;exports.RemoteRegistryV1Spec=N;exports.RemoteRegistryV2Spec=Z;exports.SemVer=p;exports.Sha256Schema=E;exports.SingleBlockPackOverview=H;exports.StableChannel=k;exports.VersionWithChannels=G;exports.Workflow=D;exports.WorkflowV1=m;exports.addPrefixToRelative=dt;exports.blockPackIdEquals=gt;exports.blockPackIdNoVersionEquals=pt;exports.blockPackIdNoVersionToString=kt;exports.blockPackIdToString=zt;exports.blockPackOverviewToLegacy=At;exports.mapRemoteToAbsolute=y;exports.overrideDescriptionVersion=bt;exports.overrideManifestVersion=Pt;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),X=require("remeda");function Y(e){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const o in e)if(o!=="default"){const l=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(n,o,l.get?l:{enumerable:!0,get:()=>e[o]})}}return n.default=e,Object.freeze(n)}const h=Y(X),tt={},s=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),r=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),i=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),R=new RegExp("^(/|[A-Z]:\\\\)"),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(R,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),d=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),A=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),et=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(R,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),nt=t.z.discriminatedUnion("type",[s,r,i,c,d]),ot=t.z.discriminatedUnion("type",[s,r,i]),it=t.z.discriminatedUnion("type",[s,r,i,c]),rt=t.z.discriminatedUnion("type",[s,r,i,d]),S=t.z.discriminatedUnion("type",[r,i,c]),j=t.z.discriminatedUnion("type",[s,i,c]),st=t.z.discriminatedUnion("type",[r,d]),ct=t.z.discriminatedUnion("type",[r,c]),at=t.z.discriminatedUnion("type",[s,d]),lt=t.z.discriminatedUnion("type",[s,c]),g=t.z.discriminatedUnion("type",[r,i]),w=t.z.discriminatedUnion("type",[s,i]),x=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),S]),V=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),j]),p=t.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,"Wrong version format, please use valid semver");function y(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"absolute-url",url:n+o.path}:o}function dt(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"relative",path:n+o.path}:o}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:p}).strict(),M=a.omit({version:!0});function zt(e){if(e!==void 0)return`${e.organization}:${e.name}:${e.version}`}function kt(e){if(e!==void 0)return`${e.organization}:${e.name}`}function gt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization&&e.version===n.version}function pt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization}function m(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function D(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(m(e)),t.z.discriminatedUnion("type",[m(e)])])}function u(e,n){return t.z.object({workflow:D(e),model:e,ui:n})}const f=u(t.z.string(),t.z.string());function ut(e){return u(g.transform(y(e)),g.transform(y(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()}),marketplaceRanking:t.z.number().optional(),termsOfServiceUrl:t.z.string().url().optional()})}const b=z(V,x),yt=z(t.z.string(),r),v=z(t.z.string(),A),mt=t.z.object({components:f,meta:b});function B(e,n){return t.z.object({id:a,components:e,meta:n})}const ft=B(f,b);function bt(e,n){return h.mergeDeep(e,{id:{version:n}})}const I=u(i,i),T=z(w,g),U=B(I,T),E=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),L=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:E}),vt=t.z.object({schema:t.z.literal("v2"),description:U,timestamp:t.z.number().optional(),files:t.z.array(L)}),Bt="manifest.json";function Pt(e,n){return h.mergeDeep(e,{description:{id:{version:n}}})}const O=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),W=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),$=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a,channel:t.z.string().optional()}),P=t.z.discriminatedUnion("type",[O,F,W,$]),q=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),N=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),Z=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),_=t.z.discriminatedUnion("type",[N,Z,q]),C=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:_}),Ct=t.z.array(C),ht=t.z.object({registryId:t.z.string(),id:a,meta:v,spec:P,otherVersions:t.z.array(p)}),J="any",k="stable",G=t.z.object({version:p,channels:t.z.array(t.z.string())}),H=t.z.object({id:a,meta:v,spec:P}),K=t.z.object({id:M,latestByChannel:t.z.record(t.z.string(),H),allVersions:t.z.array(G),registryId:t.z.string()}),Q=C.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),Rt=t.z.object({registries:t.z.array(Q),blockPacks:t.z.array(K)});function At(e){const n=e.latestByChannel[k]!==void 0?k:J,o=e.latestByChannel[n];return{id:o.id,meta:o.meta,spec:{...o.spec,channel:k},otherVersions:e.allVersions.filter(l=>l.channels.indexOf(n)>=0).map(l=>l.version),registryId:e.registryId}}const St=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.AnyChannel=J;exports.BlockComponents=u;exports.BlockComponentsAbsoluteUrl=ut;exports.BlockComponentsDescriptionRaw=f;exports.BlockComponentsManifest=I;exports.BlockPackDescriptionFromPackageJsonRaw=mt;exports.BlockPackDescriptionManifest=U;exports.BlockPackDescriptionRaw=ft;exports.BlockPackDevV1=O;exports.BlockPackDevV2=F;exports.BlockPackFromRegistryV1=W;exports.BlockPackFromRegistryV2=$;exports.BlockPackId=a;exports.BlockPackIdNoVersion=M;exports.BlockPackListing=Rt;exports.BlockPackManifest=vt;exports.BlockPackManifestFile=Bt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=b;exports.BlockPackMetaEmbeddedBase64=yt;exports.BlockPackMetaEmbeddedBytes=v;exports.BlockPackMetaManifest=T;exports.BlockPackOverview=K;exports.BlockPackOverviewLegacy=ht;exports.BlockPackSpec=P;exports.ContentAbsoluteBinaryLocal=ct;exports.ContentAbsoluteBinaryRemote=st;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=et;exports.ContentAbsoluteTextLocal=lt;exports.ContentAbsoluteTextRemote=at;exports.ContentAbsoluteUrl=d;exports.ContentAny=nt;exports.ContentAnyBinaryLocal=S;exports.ContentAnyLocal=it;exports.ContentAnyRemote=rt;exports.ContentAnyTextLocal=j;exports.ContentExplicitBase64=r;exports.ContentExplicitBytes=A;exports.ContentExplicitOrRelative=ot;exports.ContentExplicitString=s;exports.ContentRelative=i;exports.ContentRelativeBinary=g;exports.ContentRelativeText=w;exports.CreateBlockPackDescriptionSchema=B;exports.DescriptionContentBinary=x;exports.DescriptionContentText=V;exports.InitialBlockSettings=tt;exports.LocalDevFolder=q;exports.ManifestFileInfo=L;exports.PFrameInternal=St;exports.RegistryEntry=C;exports.RegistryList=Ct;exports.RegistrySpec=_;exports.RegistryStatus=Q;exports.RemoteRegistryV1Spec=N;exports.RemoteRegistryV2Spec=Z;exports.SemVer=p;exports.Sha256Schema=E;exports.SingleBlockPackOverview=H;exports.StableChannel=k;exports.VersionWithChannels=G;exports.Workflow=D;exports.WorkflowV1=m;exports.addPrefixToRelative=dt;exports.blockPackIdEquals=gt;exports.blockPackIdNoVersionEquals=pt;exports.blockPackIdNoVersionToString=kt;exports.blockPackIdToString=zt;exports.blockPackOverviewToLegacy=At;exports.mapRemoteToAbsolute=y;exports.overrideDescriptionVersion=bt;exports.overrideManifestVersion=Pt;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/block_settings.ts","../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["/**\n * What part of block version should be locked against updates.\n *\n *   - `major` - 1.2.3 can be updated to 1.4.7\n *   - `minor` - 1.2.3 can be updated to 1.2.5\n *   - `patch` - version of the block is completely locked\n *\n * */\nexport type VersionLock = 'major' | 'minor' | 'patch';\n\n/**\n * Block settings, persisted on the backend.\n *\n * Settings modulate different aspects of block behaviour,\n * currently only updates.\n * */\nexport type BlockSettings = {\n  /** Only version stricktly greater that this one will be suggested for auto-update. */\n  skipVersion?: string;\n  /**\n   * If certain version locking policy is set, auto-updates will only be suggested,\n   * if there is an update within the specified release line.\n   * */\n  versionLock?: VersionLock;\n};\n\nexport const InitialBlockSettings: BlockSettings = {};\n","import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z\n      .string()\n      .regex(absPathRegex, 'path to file must be absolute')\n      .describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .regex(absPathRegex, 'path to folder must be absolute')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal('workflow-v1'),\n    main: contentType.describe('Main workflow')\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: 'workflow-v1' as const,\n        main: value\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [WorkflowV1(contentType)])\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    }),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId,\n  channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n  BlockPackId,\n  BlockPackIdNoVersion,\n  BlockPackMetaEmbeddedBytes,\n  SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n  version: SemVer,\n  channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  id: BlockPackIdNoVersion,\n  latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n  allVersions: z.array(VersionWithChannels),\n  registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n  const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n  const latestOverview = bpo.latestByChannel[mainChannel];\n  return {\n    id: latestOverview.id,\n    meta: latestOverview.meta,\n    // so we only add stable channel specs to projects, to smooth the transition\n    spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n    otherVersions: bpo.allVersions\n      .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n      .map((v) => v.version),\n    registryId: bpo.registryId\n  };\n}\n"],"names":["InitialBlockSettings","ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/block_settings.ts","../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["/**\n * What part of block version should be locked against updates.\n *\n *   - `major` - 1.2.3 can be updated to 1.4.7\n *   - `minor` - 1.2.3 can be updated to 1.2.5\n *   - `patch` - version of the block is completely locked\n *\n * */\nexport type VersionLock = 'major' | 'minor' | 'patch';\n\n/**\n * Block settings, persisted on the backend.\n *\n * Settings modulate different aspects of block behaviour,\n * currently only updates.\n * */\nexport type BlockSettings = {\n  /** Only version stricktly greater that this one will be suggested for auto-update. */\n  skipVersion?: string;\n  /**\n   * If certain version locking policy is set, auto-updates will only be suggested,\n   * if there is an update within the specified release line.\n   * */\n  versionLock?: VersionLock;\n};\n\nexport const InitialBlockSettings: BlockSettings = {};\n","import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z\n      .string()\n      .regex(absPathRegex, 'path to file must be absolute')\n      .describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .regex(absPathRegex, 'path to folder must be absolute')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal('workflow-v1'),\n    main: contentType.describe('Main workflow')\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: 'workflow-v1' as const,\n        main: value\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [WorkflowV1(contentType)])\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    }),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional()\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId,\n  channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n  BlockPackId,\n  BlockPackIdNoVersion,\n  BlockPackMetaEmbeddedBytes,\n  SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n  version: SemVer,\n  channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  id: BlockPackIdNoVersion,\n  latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n  allVersions: z.array(VersionWithChannels),\n  registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n  const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n  const latestOverview = bpo.latestByChannel[mainChannel];\n  return {\n    id: latestOverview.id,\n    meta: latestOverview.meta,\n    // so we only add stable channel specs to projects, to smooth the transition\n    spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n    otherVersions: bpo.allVersions\n      .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n      .map((v) => v.version),\n    registryId: bpo.registryId\n  };\n}\n"],"names":["InitialBlockSettings","ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}

package/dist/index.mjs

@@ -159,7 +159,11 @@ function d(e, n) {
      * The order of blocks on the "marketplace" (higher values push block higher to the top of the list).
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
-    marketplaceRanking: t.number().optional()
+    marketplaceRanking: t.number().optional(),
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: t.string().url().optional()
   });
 }
 const B = d(
@@ -209,11 +213,11 @@ const F = t.object({
   type: t.literal("dev-v1"),
   folder: t.string(),
   mtime: t.string().optional()
-}), W = t.object({
+}), O = t.object({
   type: t.literal("dev-v2"),
   folder: t.string(),
   mtime: t.string().optional()
-}), O = t.object({
+}), W = t.object({
   type: t.literal("from-registry-v1"),
   registryUrl: t.string(),
   id: a
@@ -224,8 +228,8 @@ const F = t.object({
   channel: t.string().optional()
 }), j = t.discriminatedUnion("type", [
   F,
-  W,
   O,
+  W,
   $
 ]), Z = t.object({
   type: t.literal("local-dev"),
@@ -292,8 +296,8 @@ export {
   E as BlockPackDescriptionManifest,
   kt as BlockPackDescriptionRaw,
   F as BlockPackDevV1,
-  W as BlockPackDevV2,
-  O as BlockPackFromRegistryV1,
+  O as BlockPackDevV2,
+  W as BlockPackFromRegistryV1,
   $ as BlockPackFromRegistryV2,
   a as BlockPackId,
   z as BlockPackIdNoVersion,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/block_settings.ts","../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["/**\n * What part of block version should be locked against updates.\n *\n *   - `major` - 1.2.3 can be updated to 1.4.7\n *   - `minor` - 1.2.3 can be updated to 1.2.5\n *   - `patch` - version of the block is completely locked\n *\n * */\nexport type VersionLock = 'major' | 'minor' | 'patch';\n\n/**\n * Block settings, persisted on the backend.\n *\n * Settings modulate different aspects of block behaviour,\n * currently only updates.\n * */\nexport type BlockSettings = {\n  /** Only version stricktly greater that this one will be suggested for auto-update. */\n  skipVersion?: string;\n  /**\n   * If certain version locking policy is set, auto-updates will only be suggested,\n   * if there is an update within the specified release line.\n   * */\n  versionLock?: VersionLock;\n};\n\nexport const InitialBlockSettings: BlockSettings = {};\n","import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z\n      .string()\n      .regex(absPathRegex, 'path to file must be absolute')\n      .describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .regex(absPathRegex, 'path to folder must be absolute')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal('workflow-v1'),\n    main: contentType.describe('Main workflow')\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: 'workflow-v1' as const,\n        main: value\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [WorkflowV1(contentType)])\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    }),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId,\n  channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n  BlockPackId,\n  BlockPackIdNoVersion,\n  BlockPackMetaEmbeddedBytes,\n  SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n  version: SemVer,\n  channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  id: BlockPackIdNoVersion,\n  latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n  allVersions: z.array(VersionWithChannels),\n  registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n  const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n  const latestOverview = bpo.latestByChannel[mainChannel];\n  return {\n    id: latestOverview.id,\n    meta: latestOverview.meta,\n    // so we only add stable channel specs to projects, to smooth the transition\n    spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n    otherVersions: bpo.allVersions\n      .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n      .map((v) => v.version),\n    registryId: bpo.registryId\n  };\n}\n"],"names":["InitialBlockSettings","ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
+{"version":3,"file":"index.mjs","sources":["../src/block_settings.ts","../src/block_meta/content_types.ts","../src/block_meta/semver.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_id.ts","../src/block_meta/block_components.ts","../src/block_meta/block_meta.ts","../src/block_meta/block_description.ts","../src/block_meta/block_manifest.ts","../src/block_registry/block_pack_spec.ts","../src/block_registry/registry_spec.ts","../src/block_registry/overview.ts"],"sourcesContent":["/**\n * What part of block version should be locked against updates.\n *\n *   - `major` - 1.2.3 can be updated to 1.4.7\n *   - `minor` - 1.2.3 can be updated to 1.2.5\n *   - `patch` - version of the block is completely locked\n *\n * */\nexport type VersionLock = 'major' | 'minor' | 'patch';\n\n/**\n * Block settings, persisted on the backend.\n *\n * Settings modulate different aspects of block behaviour,\n * currently only updates.\n * */\nexport type BlockSettings = {\n  /** Only version stricktly greater that this one will be suggested for auto-update. */\n  skipVersion?: string;\n  /**\n   * If certain version locking policy is set, auto-updates will only be suggested,\n   * if there is an update within the specified release line.\n   * */\n  versionLock?: VersionLock;\n};\n\nexport const InitialBlockSettings: BlockSettings = {};\n","import { z } from 'zod';\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal('explicit-string'),\n    content: z.string().describe('Actual string value')\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal('explicit-base64'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.string().base64().describe('Base64 encoded binary value')\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal('relative'),\n    path: z\n      .string()\n      .describe(\n        'Address of the file, in most cases relative to the file which this structure is a part of'\n      )\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z\n      .string()\n      .regex(absPathRegex, 'path to file must be absolute')\n      .describe('Absolute address of the file in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal('absolute-url'),\n    url: z.string().url().describe('Global URL to reach the requested file')\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal('explicit-bytes'),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe('MIME type to interpret content'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .regex(absPathRegex, 'path to folder must be absolute')\n      .describe('Absolute address of the folder in local file system')\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteUrl\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentAbsoluteFile\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion('type', [\n  ContentExplicitBase64,\n  ContentRelative\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion('type', [\n  ContentExplicitString,\n  ContentRelative\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith('file:')\n    .transform<ContentRelativeBinary>((value, ctx) => ({ type: 'relative', path: value.slice(5) })),\n  ContentAnyBinaryLocal\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value, ctx) => {\n    if (value.startsWith('file:')) return { type: 'relative', path: value.slice(5) };\n    else return { type: 'explicit-string', content: value };\n  }),\n  ContentAnyTextLocal\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n","import { z } from 'zod';\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    'Wrong version format, please use valid semver'\n  );\n","import {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative\n} from './content_types';\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === 'relative'\n      ? { type: 'absolute-url', url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relaive path, slesh at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith('/') ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === 'relative'\n      ? { type: 'relative', path: prefixWithSlash + value.path }\n      : value) as T;\n}\n","import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.object({\n    type: z.literal('workflow-v1'),\n    main: contentType.describe('Main workflow')\n  });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType\n      .transform((value: z.infer<typeof contentType>) => ({\n        type: 'workflow-v1' as const,\n        main: value\n      }))\n      .pipe(WorkflowV1(contentType)),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [WorkflowV1(contentType)])\n  ]);\n}\n\nexport function BlockComponents<\n  const WfAndModel extends z.ZodTypeAny,\n  const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n  return z.object({\n    workflow: Workflow(wfAndModel),\n    model: wfAndModel,\n    ui\n  });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n  return BlockComponents(\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n  );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    }),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional()\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n  type: z.literal('dev-v1'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n  type: z.literal('dev-v2'),\n  folder: z.string(),\n  mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n  type: z.literal('from-registry-v1'),\n  registryUrl: z.string(),\n  id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n  type: z.literal('from-registry-v2'),\n  registryUrl: z.string(),\n  id: BlockPackId,\n  channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n  BlockPackDevV1,\n  BlockPackDevV2,\n  BlockPackFromRegistryV1,\n  BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n  type: z.literal('local-dev'),\n  path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n  type: z.literal('remote-v1'),\n  url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n  type: z.literal('remote-v2'),\n  url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n  RemoteRegistryV1Spec,\n  RemoteRegistryV2Spec,\n  LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n  id: z.string(),\n  title: z.string().optional(),\n  spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n  BlockPackId,\n  BlockPackIdNoVersion,\n  BlockPackMetaEmbeddedBytes,\n  SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n  registryId: z.string(),\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec,\n  otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n  version: SemVer,\n  channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n  id: BlockPackId,\n  meta: BlockPackMetaEmbeddedBytes,\n  spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n  id: BlockPackIdNoVersion,\n  latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n  allVersions: z.array(VersionWithChannels),\n  registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n  status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n  registries: z.array(RegistryStatus),\n  blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n  const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n  const latestOverview = bpo.latestByChannel[mainChannel];\n  return {\n    id: latestOverview.id,\n    meta: latestOverview.meta,\n    // so we only add stable channel specs to projects, to smooth the transition\n    spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n    otherVersions: bpo.allVersions\n      .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n      .map((v) => v.version),\n    registryId: bpo.registryId\n  };\n}\n"],"names":["InitialBlockSettings","ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}

package/dist/project_overview.d.ts

@@ -27,6 +27,8 @@ export type ProjectOverview = {
 };
 /** Overview of the block state, required for visualization in the left panel */
 export type BlockStateOverview = {
+    /** Project resource id (one of the goals it to be used for debugging purposes) */
+    projectResourceId: string;
     /** Block id */
     id: string;
     /**

package/dist/project_overview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project_overview.d.ts","sourceRoot":"","sources":["../src/project_overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,oEAAoE;AACpE,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAEpF,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG;IAC5B,+DAA+D;IAC/D,IAAI,EAAE,WAAW,CAAC;IAElB,0BAA0B;IAC1B,OAAO,EAAE,IAAI,CAAC;IAEd,mCAAmC;IACnC,YAAY,EAAE,IAAI,CAAC;IAEnB;;;;;;SAMK;IACL,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,0CAA0C;IAC1C,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAC9B,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,eAAe;IACf,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;SAKK;IACL,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B;;;OAGG;IACH,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B,2BAA2B;IAC3B,aAAa,EAAE,kBAAkB,CAAC;IAElC;;;SAGK;IACL,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;;SAKK;IACL,KAAK,EAAE,OAAO,CAAC;IAEf;;;SAGK;IACL,YAAY,EAAE,OAAO,CAAC;IAEtB;;;SAGK;IACL,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;SAGK;IACL,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,2CAA2C;IAC3C,iBAAiB,EAAE,sBAAsB,CAAC;IAE1C;;;SAGK;IACL,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;;SAGK;IACL,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB;;;SAGK;IACL,QAAQ,EAAE,YAAY,EAAE,GAAG,SAAS,CAAC;IAErC;;;SAGK;IACL,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC;IAEjC;;;SAGK;IACL,MAAM,EAAE,OAAO,CAAC;IAEhB;;;SAGK;IACL,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B,mEAAmE;IACnE,gBAAgB,EAAE,aAAa,GAAG,SAAS,CAAC;IAE5C;;;SAGK;IACL,gBAAgB,EAAE,aAAa,GAAG,SAAS,CAAC;IAE5C,6BAA6B;IAC7B,QAAQ,EAAE,aAAa,CAAC;IAExB,8BAA8B;IAC9B,iBAAiB,EAAE,iBAAiB,CAAC;IAErC,4CAA4C;IAC5C,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC"}
+{"version":3,"file":"project_overview.d.ts","sourceRoot":"","sources":["../src/project_overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,oEAAoE;AACpE,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAEpF,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG;IAC5B,+DAA+D;IAC/D,IAAI,EAAE,WAAW,CAAC;IAElB,0BAA0B;IAC1B,OAAO,EAAE,IAAI,CAAC;IAEd,mCAAmC;IACnC,YAAY,EAAE,IAAI,CAAC;IAEnB;;;;;;SAMK;IACL,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,0CAA0C;IAC1C,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAC9B,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,kFAAkF;IAClF,iBAAiB,EAAE,MAAM,CAAC;IAE1B,eAAe;IACf,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;SAKK;IACL,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B;;;OAGG;IACH,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B,2BAA2B;IAC3B,aAAa,EAAE,kBAAkB,CAAC;IAElC;;;SAGK;IACL,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;;SAKK;IACL,KAAK,EAAE,OAAO,CAAC;IAEf;;;SAGK;IACL,YAAY,EAAE,OAAO,CAAC;IAEtB;;;SAGK;IACL,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;SAGK;IACL,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,2CAA2C;IAC3C,iBAAiB,EAAE,sBAAsB,CAAC;IAE1C;;;SAGK;IACL,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;;SAGK;IACL,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB;;;SAGK;IACL,QAAQ,EAAE,YAAY,EAAE,GAAG,SAAS,CAAC;IAErC;;;SAGK;IACL,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC;IAEjC;;;SAGK;IACL,MAAM,EAAE,OAAO,CAAC;IAEhB;;;SAGK;IACL,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B,mEAAmE;IACnE,gBAAgB,EAAE,aAAa,GAAG,SAAS,CAAC;IAE5C;;;SAGK;IACL,gBAAgB,EAAE,aAAa,GAAG,SAAS,CAAC;IAE5C,6BAA6B;IAC7B,QAAQ,EAAE,aAAa,CAAC;IAExB,8BAA8B;IAC9B,iBAAiB,EAAE,iBAAiB,CAAC;IAErC,4CAA4C;IAC5C,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-middle-layer",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "description": "Common model between middle layer and non-block UI code",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -17,7 +17,7 @@
     "./src/**/*"
   ],
   "dependencies": {
-    "remeda": "^2.19.2",
+    "remeda": "^2.21.1",
     "zod": "~3.23.8",
     "utility-types": "^3.11.0",
     "@milaboratories/pl-model-common": "^1.10.6"

package/src/block_meta/block_meta.ts

@@ -30,6 +30,10 @@ export function BlockPackMeta<
      * `undefined` value or absent field is treated exactly the same as number `0`.
      */
     marketplaceRanking: z.number().optional(),
+    /**
+     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
+     */
+    termsOfServiceUrl: z.string().url().optional()
   });
 }
 

package/src/project_overview.ts

@@ -34,6 +34,9 @@ export type ProjectOverview = {
 
 /** Overview of the block state, required for visualization in the left panel */
 export type BlockStateOverview = {
+  /** Project resource id (one of the goals it to be used for debugging purposes) */
+  projectResourceId: string;
+
   /** Block id */
   id: string;