@milaboratories/pl-model-middle-layer 1.5.6 → 1.5.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/block_meta/block_description.d.ts +10 -0
- package/dist/block_meta/block_description.d.ts.map +1 -1
- package/dist/block_meta/block_manifest.d.ts +15 -0
- package/dist/block_meta/block_manifest.d.ts.map +1 -1
- package/dist/block_meta/block_meta.d.ts +14 -0
- package/dist/block_meta/block_meta.d.ts.map +1 -1
- package/dist/block_registry/overview.d.ts +12 -0
- package/dist/block_registry/overview.d.ts.map +1 -1
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +9 -7
- package/dist/index.mjs.map +1 -1
- package/package.json +2 -2
- package/src/block_meta/block_meta.ts +3 -1
|
@@ -226,6 +226,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
226
226
|
file: string;
|
|
227
227
|
} | undefined;
|
|
228
228
|
}>;
|
|
229
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
229
230
|
}, "strip", z.ZodTypeAny, {
|
|
230
231
|
organization: {
|
|
231
232
|
url: string;
|
|
@@ -279,6 +280,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
279
280
|
docs?: string | undefined;
|
|
280
281
|
support?: string | undefined;
|
|
281
282
|
tags?: string[] | undefined;
|
|
283
|
+
marketplaceRanking?: number | undefined;
|
|
282
284
|
}, {
|
|
283
285
|
organization: {
|
|
284
286
|
url: string;
|
|
@@ -332,6 +334,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
332
334
|
docs?: string | undefined;
|
|
333
335
|
support?: string | undefined;
|
|
334
336
|
tags?: string[] | undefined;
|
|
337
|
+
marketplaceRanking?: number | undefined;
|
|
335
338
|
}>;
|
|
336
339
|
}, "strip", z.ZodTypeAny, {
|
|
337
340
|
components: {
|
|
@@ -395,6 +398,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
395
398
|
docs?: string | undefined;
|
|
396
399
|
support?: string | undefined;
|
|
397
400
|
tags?: string[] | undefined;
|
|
401
|
+
marketplaceRanking?: number | undefined;
|
|
398
402
|
};
|
|
399
403
|
}, {
|
|
400
404
|
components: {
|
|
@@ -458,6 +462,7 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
458
462
|
docs?: string | undefined;
|
|
459
463
|
support?: string | undefined;
|
|
460
464
|
tags?: string[] | undefined;
|
|
465
|
+
marketplaceRanking?: number | undefined;
|
|
461
466
|
};
|
|
462
467
|
}>;
|
|
463
468
|
export declare function CreateBlockPackDescriptionSchema<Components extends ZodTypeAny, Meta extends ZodTypeAny>(components: Components, meta: Meta): z.ZodObject<{
|
|
@@ -778,6 +783,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
778
783
|
file: string;
|
|
779
784
|
} | undefined;
|
|
780
785
|
}>;
|
|
786
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
781
787
|
}, "strip", z.ZodTypeAny, {
|
|
782
788
|
organization: {
|
|
783
789
|
url: string;
|
|
@@ -831,6 +837,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
831
837
|
docs?: string | undefined;
|
|
832
838
|
support?: string | undefined;
|
|
833
839
|
tags?: string[] | undefined;
|
|
840
|
+
marketplaceRanking?: number | undefined;
|
|
834
841
|
}, {
|
|
835
842
|
organization: {
|
|
836
843
|
url: string;
|
|
@@ -884,6 +891,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
884
891
|
docs?: string | undefined;
|
|
885
892
|
support?: string | undefined;
|
|
886
893
|
tags?: string[] | undefined;
|
|
894
|
+
marketplaceRanking?: number | undefined;
|
|
887
895
|
}>;
|
|
888
896
|
}, "strip", z.ZodTypeAny, {
|
|
889
897
|
components: {
|
|
@@ -947,6 +955,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
947
955
|
docs?: string | undefined;
|
|
948
956
|
support?: string | undefined;
|
|
949
957
|
tags?: string[] | undefined;
|
|
958
|
+
marketplaceRanking?: number | undefined;
|
|
950
959
|
};
|
|
951
960
|
id: {
|
|
952
961
|
organization: string;
|
|
@@ -1015,6 +1024,7 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
1015
1024
|
docs?: string | undefined;
|
|
1016
1025
|
support?: string | undefined;
|
|
1017
1026
|
tags?: string[] | undefined;
|
|
1027
|
+
marketplaceRanking?: number | undefined;
|
|
1018
1028
|
};
|
|
1019
1029
|
id: {
|
|
1020
1030
|
organization: string;
|
|
@@ -1 +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;AAKpC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC
|
|
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;AAKpC;;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"}
|
|
@@ -239,6 +239,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
|
|
|
239
239
|
path: string;
|
|
240
240
|
} | undefined;
|
|
241
241
|
}>;
|
|
242
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
242
243
|
}, "strip", z.ZodTypeAny, {
|
|
243
244
|
organization: {
|
|
244
245
|
url: string;
|
|
@@ -280,6 +281,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
|
|
|
280
281
|
docs?: string | undefined;
|
|
281
282
|
support?: string | undefined;
|
|
282
283
|
tags?: string[] | undefined;
|
|
284
|
+
marketplaceRanking?: number | undefined;
|
|
283
285
|
}, {
|
|
284
286
|
organization: {
|
|
285
287
|
url: string;
|
|
@@ -321,6 +323,7 @@ export declare const BlockPackMetaManifest: z.ZodObject<{
|
|
|
321
323
|
docs?: string | undefined;
|
|
322
324
|
support?: string | undefined;
|
|
323
325
|
tags?: string[] | undefined;
|
|
326
|
+
marketplaceRanking?: number | undefined;
|
|
324
327
|
}>;
|
|
325
328
|
export type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;
|
|
326
329
|
/** Block description to be used in block manifest */
|
|
@@ -577,6 +580,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
|
|
|
577
580
|
path: string;
|
|
578
581
|
} | undefined;
|
|
579
582
|
}>;
|
|
583
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
580
584
|
}, "strip", z.ZodTypeAny, {
|
|
581
585
|
organization: {
|
|
582
586
|
url: string;
|
|
@@ -618,6 +622,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
|
|
|
618
622
|
docs?: string | undefined;
|
|
619
623
|
support?: string | undefined;
|
|
620
624
|
tags?: string[] | undefined;
|
|
625
|
+
marketplaceRanking?: number | undefined;
|
|
621
626
|
}, {
|
|
622
627
|
organization: {
|
|
623
628
|
url: string;
|
|
@@ -659,6 +664,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
|
|
|
659
664
|
docs?: string | undefined;
|
|
660
665
|
support?: string | undefined;
|
|
661
666
|
tags?: string[] | undefined;
|
|
667
|
+
marketplaceRanking?: number | undefined;
|
|
662
668
|
}>;
|
|
663
669
|
}, "strip", z.ZodTypeAny, {
|
|
664
670
|
components: {
|
|
@@ -719,6 +725,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
|
|
|
719
725
|
docs?: string | undefined;
|
|
720
726
|
support?: string | undefined;
|
|
721
727
|
tags?: string[] | undefined;
|
|
728
|
+
marketplaceRanking?: number | undefined;
|
|
722
729
|
};
|
|
723
730
|
id: {
|
|
724
731
|
organization: string;
|
|
@@ -787,6 +794,7 @@ export declare const BlockPackDescriptionManifest: z.ZodObject<{
|
|
|
787
794
|
docs?: string | undefined;
|
|
788
795
|
support?: string | undefined;
|
|
789
796
|
tags?: string[] | undefined;
|
|
797
|
+
marketplaceRanking?: number | undefined;
|
|
790
798
|
};
|
|
791
799
|
id: {
|
|
792
800
|
organization: string;
|
|
@@ -1065,6 +1073,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1065
1073
|
path: string;
|
|
1066
1074
|
} | undefined;
|
|
1067
1075
|
}>;
|
|
1076
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
1068
1077
|
}, "strip", z.ZodTypeAny, {
|
|
1069
1078
|
organization: {
|
|
1070
1079
|
url: string;
|
|
@@ -1106,6 +1115,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1106
1115
|
docs?: string | undefined;
|
|
1107
1116
|
support?: string | undefined;
|
|
1108
1117
|
tags?: string[] | undefined;
|
|
1118
|
+
marketplaceRanking?: number | undefined;
|
|
1109
1119
|
}, {
|
|
1110
1120
|
organization: {
|
|
1111
1121
|
url: string;
|
|
@@ -1147,6 +1157,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1147
1157
|
docs?: string | undefined;
|
|
1148
1158
|
support?: string | undefined;
|
|
1149
1159
|
tags?: string[] | undefined;
|
|
1160
|
+
marketplaceRanking?: number | undefined;
|
|
1150
1161
|
}>;
|
|
1151
1162
|
}, "strip", z.ZodTypeAny, {
|
|
1152
1163
|
components: {
|
|
@@ -1207,6 +1218,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1207
1218
|
docs?: string | undefined;
|
|
1208
1219
|
support?: string | undefined;
|
|
1209
1220
|
tags?: string[] | undefined;
|
|
1221
|
+
marketplaceRanking?: number | undefined;
|
|
1210
1222
|
};
|
|
1211
1223
|
id: {
|
|
1212
1224
|
organization: string;
|
|
@@ -1275,6 +1287,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1275
1287
|
docs?: string | undefined;
|
|
1276
1288
|
support?: string | undefined;
|
|
1277
1289
|
tags?: string[] | undefined;
|
|
1290
|
+
marketplaceRanking?: number | undefined;
|
|
1278
1291
|
};
|
|
1279
1292
|
id: {
|
|
1280
1293
|
organization: string;
|
|
@@ -1355,6 +1368,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1355
1368
|
docs?: string | undefined;
|
|
1356
1369
|
support?: string | undefined;
|
|
1357
1370
|
tags?: string[] | undefined;
|
|
1371
|
+
marketplaceRanking?: number | undefined;
|
|
1358
1372
|
};
|
|
1359
1373
|
id: {
|
|
1360
1374
|
organization: string;
|
|
@@ -1431,6 +1445,7 @@ export declare const BlockPackManifest: z.ZodObject<{
|
|
|
1431
1445
|
docs?: string | undefined;
|
|
1432
1446
|
support?: string | undefined;
|
|
1433
1447
|
tags?: string[] | undefined;
|
|
1448
|
+
marketplaceRanking?: number | undefined;
|
|
1434
1449
|
};
|
|
1435
1450
|
id: {
|
|
1436
1451
|
organization: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AACzF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB
|
|
1
|
+
{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AACzF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4D,CAAC;AAC/F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,qDAAqD;AACrD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAExF,eAAO,MAAM,YAAY,aAIZ,CAAC;AAEd,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,qBAAqB,kBAAkB,CAAC"}
|
|
@@ -30,6 +30,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
|
|
|
30
30
|
url: z.ZodString;
|
|
31
31
|
logo: z.ZodOptional<BinaryType>;
|
|
32
32
|
}>[k_1]; }>;
|
|
33
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
33
34
|
}, "strip", z.ZodTypeAny, { [k_2 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
34
35
|
title: z.ZodString;
|
|
35
36
|
description: z.ZodString;
|
|
@@ -61,6 +62,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
|
|
|
61
62
|
url: z.ZodString;
|
|
62
63
|
logo: z.ZodOptional<BinaryType>;
|
|
63
64
|
}>[k_1]; }>;
|
|
65
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
64
66
|
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
65
67
|
title: z.ZodString;
|
|
66
68
|
description: z.ZodString;
|
|
@@ -92,6 +94,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
|
|
|
92
94
|
url: z.ZodString;
|
|
93
95
|
logo: z.ZodOptional<BinaryType>;
|
|
94
96
|
}>[k_1]; }>;
|
|
97
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
95
98
|
}>, any>[k_2]; }, { [k_1_1 in keyof z.baseObjectInputType<{
|
|
96
99
|
title: z.ZodString;
|
|
97
100
|
description: z.ZodString;
|
|
@@ -123,6 +126,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
|
|
|
123
126
|
url: z.ZodString;
|
|
124
127
|
logo: z.ZodOptional<BinaryType>;
|
|
125
128
|
}>[k_1]; }>;
|
|
129
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
126
130
|
}>]: z.baseObjectInputType<{
|
|
127
131
|
title: z.ZodString;
|
|
128
132
|
description: z.ZodString;
|
|
@@ -154,6 +158,7 @@ export declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny,
|
|
|
154
158
|
url: z.ZodString;
|
|
155
159
|
logo: z.ZodOptional<BinaryType>;
|
|
156
160
|
}>[k_1]; }>;
|
|
161
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
157
162
|
}>[k_1_1]; }>;
|
|
158
163
|
export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
|
|
159
164
|
title: z.ZodString;
|
|
@@ -338,6 +343,7 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
|
|
|
338
343
|
file: string;
|
|
339
344
|
} | undefined;
|
|
340
345
|
}>;
|
|
346
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
341
347
|
}, "strip", z.ZodTypeAny, {
|
|
342
348
|
organization: {
|
|
343
349
|
url: string;
|
|
@@ -391,6 +397,7 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
|
|
|
391
397
|
docs?: string | undefined;
|
|
392
398
|
support?: string | undefined;
|
|
393
399
|
tags?: string[] | undefined;
|
|
400
|
+
marketplaceRanking?: number | undefined;
|
|
394
401
|
}, {
|
|
395
402
|
organization: {
|
|
396
403
|
url: string;
|
|
@@ -444,6 +451,7 @@ export declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
|
|
|
444
451
|
docs?: string | undefined;
|
|
445
452
|
support?: string | undefined;
|
|
446
453
|
tags?: string[] | undefined;
|
|
454
|
+
marketplaceRanking?: number | undefined;
|
|
447
455
|
}>;
|
|
448
456
|
export type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;
|
|
449
457
|
export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
|
|
@@ -501,6 +509,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
|
|
|
501
509
|
mimeType: string;
|
|
502
510
|
} | undefined;
|
|
503
511
|
}>;
|
|
512
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
504
513
|
}, "strip", z.ZodTypeAny, {
|
|
505
514
|
organization: {
|
|
506
515
|
url: string;
|
|
@@ -524,6 +533,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
|
|
|
524
533
|
docs?: string | undefined;
|
|
525
534
|
support?: string | undefined;
|
|
526
535
|
tags?: string[] | undefined;
|
|
536
|
+
marketplaceRanking?: number | undefined;
|
|
527
537
|
}, {
|
|
528
538
|
organization: {
|
|
529
539
|
url: string;
|
|
@@ -547,6 +557,7 @@ export declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
|
|
|
547
557
|
docs?: string | undefined;
|
|
548
558
|
support?: string | undefined;
|
|
549
559
|
tags?: string[] | undefined;
|
|
560
|
+
marketplaceRanking?: number | undefined;
|
|
550
561
|
}>;
|
|
551
562
|
export type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;
|
|
552
563
|
export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
|
|
@@ -604,6 +615,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
|
|
|
604
615
|
mimeType: string;
|
|
605
616
|
} | undefined;
|
|
606
617
|
}>;
|
|
618
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
607
619
|
}, "strip", z.ZodTypeAny, {
|
|
608
620
|
organization: {
|
|
609
621
|
url: string;
|
|
@@ -627,6 +639,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
|
|
|
627
639
|
docs?: string | undefined;
|
|
628
640
|
support?: string | undefined;
|
|
629
641
|
tags?: string[] | undefined;
|
|
642
|
+
marketplaceRanking?: number | undefined;
|
|
630
643
|
}, {
|
|
631
644
|
organization: {
|
|
632
645
|
url: string;
|
|
@@ -650,6 +663,7 @@ export declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
|
|
|
650
663
|
docs?: string | undefined;
|
|
651
664
|
support?: string | undefined;
|
|
652
665
|
tags?: string[] | undefined;
|
|
666
|
+
marketplaceRanking?: number | undefined;
|
|
653
667
|
}>;
|
|
654
668
|
export type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;
|
|
655
669
|
//# sourceMappingURL=block_meta.d.ts.map
|
|
@@ -1 +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
|
|
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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmB/C;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAGtF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}
|
|
@@ -72,6 +72,7 @@ export declare const BlockPackOverview: z.ZodObject<{
|
|
|
72
72
|
mimeType: string;
|
|
73
73
|
} | undefined;
|
|
74
74
|
}>;
|
|
75
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
75
76
|
}, "strip", z.ZodTypeAny, {
|
|
76
77
|
organization: {
|
|
77
78
|
url: string;
|
|
@@ -95,6 +96,7 @@ export declare const BlockPackOverview: z.ZodObject<{
|
|
|
95
96
|
docs?: string | undefined;
|
|
96
97
|
support?: string | undefined;
|
|
97
98
|
tags?: string[] | undefined;
|
|
99
|
+
marketplaceRanking?: number | undefined;
|
|
98
100
|
}, {
|
|
99
101
|
organization: {
|
|
100
102
|
url: string;
|
|
@@ -118,6 +120,7 @@ export declare const BlockPackOverview: z.ZodObject<{
|
|
|
118
120
|
docs?: string | undefined;
|
|
119
121
|
support?: string | undefined;
|
|
120
122
|
tags?: string[] | undefined;
|
|
123
|
+
marketplaceRanking?: number | undefined;
|
|
121
124
|
}>;
|
|
122
125
|
spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
123
126
|
type: z.ZodLiteral<"dev-v1">;
|
|
@@ -233,6 +236,7 @@ export declare const BlockPackOverview: z.ZodObject<{
|
|
|
233
236
|
docs?: string | undefined;
|
|
234
237
|
support?: string | undefined;
|
|
235
238
|
tags?: string[] | undefined;
|
|
239
|
+
marketplaceRanking?: number | undefined;
|
|
236
240
|
};
|
|
237
241
|
id: {
|
|
238
242
|
organization: string;
|
|
@@ -290,6 +294,7 @@ export declare const BlockPackOverview: z.ZodObject<{
|
|
|
290
294
|
docs?: string | undefined;
|
|
291
295
|
support?: string | undefined;
|
|
292
296
|
tags?: string[] | undefined;
|
|
297
|
+
marketplaceRanking?: number | undefined;
|
|
293
298
|
};
|
|
294
299
|
id: {
|
|
295
300
|
organization: string;
|
|
@@ -521,6 +526,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
521
526
|
mimeType: string;
|
|
522
527
|
} | undefined;
|
|
523
528
|
}>;
|
|
529
|
+
marketplaceRanking: z.ZodOptional<z.ZodNumber>;
|
|
524
530
|
}, "strip", z.ZodTypeAny, {
|
|
525
531
|
organization: {
|
|
526
532
|
url: string;
|
|
@@ -544,6 +550,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
544
550
|
docs?: string | undefined;
|
|
545
551
|
support?: string | undefined;
|
|
546
552
|
tags?: string[] | undefined;
|
|
553
|
+
marketplaceRanking?: number | undefined;
|
|
547
554
|
}, {
|
|
548
555
|
organization: {
|
|
549
556
|
url: string;
|
|
@@ -567,6 +574,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
567
574
|
docs?: string | undefined;
|
|
568
575
|
support?: string | undefined;
|
|
569
576
|
tags?: string[] | undefined;
|
|
577
|
+
marketplaceRanking?: number | undefined;
|
|
570
578
|
}>;
|
|
571
579
|
spec: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
572
580
|
type: z.ZodLiteral<"dev-v1">;
|
|
@@ -682,6 +690,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
682
690
|
docs?: string | undefined;
|
|
683
691
|
support?: string | undefined;
|
|
684
692
|
tags?: string[] | undefined;
|
|
693
|
+
marketplaceRanking?: number | undefined;
|
|
685
694
|
};
|
|
686
695
|
id: {
|
|
687
696
|
organization: string;
|
|
@@ -739,6 +748,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
739
748
|
docs?: string | undefined;
|
|
740
749
|
support?: string | undefined;
|
|
741
750
|
tags?: string[] | undefined;
|
|
751
|
+
marketplaceRanking?: number | undefined;
|
|
742
752
|
};
|
|
743
753
|
id: {
|
|
744
754
|
organization: string;
|
|
@@ -813,6 +823,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
813
823
|
docs?: string | undefined;
|
|
814
824
|
support?: string | undefined;
|
|
815
825
|
tags?: string[] | undefined;
|
|
826
|
+
marketplaceRanking?: number | undefined;
|
|
816
827
|
};
|
|
817
828
|
id: {
|
|
818
829
|
organization: string;
|
|
@@ -887,6 +898,7 @@ export declare const BlockPackListing: z.ZodObject<{
|
|
|
887
898
|
docs?: string | undefined;
|
|
888
899
|
support?: string | undefined;
|
|
889
900
|
tags?: string[] | undefined;
|
|
901
|
+
marketplaceRanking?: number | undefined;
|
|
890
902
|
};
|
|
891
903
|
id: {
|
|
892
904
|
organization: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;KAEK;AACL,eAAO,MAAM,iBAAiB
|
|
1
|
+
{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;KAEK;AACL,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5B,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"}
|
package/dist/index.js
CHANGED
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),r=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=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(),n=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(),B=new RegExp("^(/|[A-Z]:\\\\)"),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(B,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),l=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),C=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(),_=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(B,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),$=t.z.discriminatedUnion("type",[r,i,n,c,l]),J=t.z.discriminatedUnion("type",[r,i,n]),G=t.z.discriminatedUnion("type",[r,i,n,c]),H=t.z.discriminatedUnion("type",[r,i,n,l]),P=t.z.discriminatedUnion("type",[i,n,c]),v=t.z.discriminatedUnion("type",[r,n,c]),K=t.z.discriminatedUnion("type",[i,l]),Q=t.z.discriminatedUnion("type",[i,c]),X=t.z.discriminatedUnion("type",[r,l]),Y=t.z.discriminatedUnion("type",[r,c]),d=t.z.discriminatedUnion("type",[i,n]),R=t.z.discriminatedUnion("type",[r,n]),A=t.z.union([t.z.string().startsWith("file:").transform((e,o)=>({type:"relative",path:e.slice(5)})),P]),h=t.z.union([t.z.string().transform((e,o)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),v]),m=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 k(e){const o=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"absolute-url",url:o+s.path}:s}function tt(e){const o=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"relative",path:o+s.path}:s}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:m}).strict(),et=a.omit({version:!0});function ot(e,o){return e===void 0&&o===void 0?!0:e===void 0||o===void 0?!1:e.name===o.name&&e.organization===o.organization&&e.version===o.version}function nt(e,o){return e===void 0&&o===void 0?!0:e===void 0||o===void 0?!1:e.name===o.name&&e.organization===o.organization}function y(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function x(e){return t.z.union([e.transform(o=>({type:"workflow-v1",main:o})).pipe(y(e)),t.z.discriminatedUnion("type",[y(e)])])}function p(e,o){return t.z.object({workflow:x(e),model:e,ui:o})}const g=p(t.z.string(),t.z.string());function it(e){return p(d.transform(k(e)),d.transform(k(e)))}function z(e,o){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:o.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:o.optional()})})}const u=z(h,A),rt=z(t.z.string(),i),j=z(t.z.string(),C),st=t.z.object({components:g,meta:u});function f(e,o){return t.z.object({id:a,components:e,meta:o})}const ct=f(g,u),w=p(n,n),M=z(R,d),S=f(w,M),D=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),U=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:D}),at=t.z.object({schema:t.z.literal("v2"),description:S,files:t.z.array(U)}),lt="manifest.json",E=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),V=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),L=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a}),T=t.z.discriminatedUnion("type",[E,V,F,L]),I=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),W=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),O=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),Z=t.z.discriminatedUnion("type",[W,O,I]),b=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:Z}),zt=t.z.array(b),q=t.z.object({registryId:t.z.string(),id:a,meta:j,spec:T,otherVersions:t.z.array(m)}),N=b.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),dt=t.z.object({registries:t.z.array(N),blockPacks:t.z.array(q)}),pt=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=p;exports.BlockComponentsAbsoluteUrl=it;exports.BlockComponentsDescriptionRaw=g;exports.BlockComponentsManifest=w;exports.BlockPackDescriptionFromPackageJsonRaw=st;exports.BlockPackDescriptionManifest=S;exports.BlockPackDescriptionRaw=ct;exports.BlockPackDevV1=E;exports.BlockPackDevV2=V;exports.BlockPackFromRegistryV1=F;exports.BlockPackFromRegistryV2=L;exports.BlockPackId=a;exports.BlockPackIdNoVersion=et;exports.BlockPackListing=dt;exports.BlockPackManifest=at;exports.BlockPackManifestFile=lt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=u;exports.BlockPackMetaEmbeddedBase64=rt;exports.BlockPackMetaEmbeddedBytes=j;exports.BlockPackMetaManifest=M;exports.BlockPackOverview=q;exports.BlockPackSpec=T;exports.ContentAbsoluteBinaryLocal=Q;exports.ContentAbsoluteBinaryRemote=K;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=_;exports.ContentAbsoluteTextLocal=Y;exports.ContentAbsoluteTextRemote=X;exports.ContentAbsoluteUrl=l;exports.ContentAny=$;exports.ContentAnyBinaryLocal=P;exports.ContentAnyLocal=G;exports.ContentAnyRemote=H;exports.ContentAnyTextLocal=v;exports.ContentExplicitBase64=i;exports.ContentExplicitBytes=C;exports.ContentExplicitOrRelative=J;exports.ContentExplicitString=r;exports.ContentRelative=n;exports.ContentRelativeBinary=d;exports.ContentRelativeText=R;exports.CreateBlockPackDescriptionSchema=f;exports.DescriptionContentBinary=A;exports.DescriptionContentText=h;exports.LocalDevFolder=I;exports.ManifestFileInfo=U;exports.PFrameInternal=pt;exports.RegistryEntry=b;exports.RegistryList=zt;exports.RegistrySpec=Z;exports.RegistryStatus=N;exports.RemoteRegistryV1Spec=W;exports.RemoteRegistryV2Spec=O;exports.SemVer=m;exports.Sha256Schema=D;exports.Workflow=x;exports.WorkflowV1=y;exports.addPrefixToRelative=tt;exports.blockPackIdEquals=ot;exports.blockPackIdNoVersionEquals=nt;exports.mapRemoteToAbsolute=k;
|
|
1
|
+
"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),r=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=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(),n=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(),B=new RegExp("^(/|[A-Z]:\\\\)"),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(B,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),l=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),C=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(),_=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(B,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),$=t.z.discriminatedUnion("type",[r,i,n,c,l]),J=t.z.discriminatedUnion("type",[r,i,n]),G=t.z.discriminatedUnion("type",[r,i,n,c]),H=t.z.discriminatedUnion("type",[r,i,n,l]),P=t.z.discriminatedUnion("type",[i,n,c]),v=t.z.discriminatedUnion("type",[r,n,c]),K=t.z.discriminatedUnion("type",[i,l]),Q=t.z.discriminatedUnion("type",[i,c]),X=t.z.discriminatedUnion("type",[r,l]),Y=t.z.discriminatedUnion("type",[r,c]),d=t.z.discriminatedUnion("type",[i,n]),R=t.z.discriminatedUnion("type",[r,n]),A=t.z.union([t.z.string().startsWith("file:").transform((e,o)=>({type:"relative",path:e.slice(5)})),P]),h=t.z.union([t.z.string().transform((e,o)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),v]),m=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 k(e){const o=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"absolute-url",url:o+s.path}:s}function tt(e){const o=e.endsWith("/")?e:`${e}/`;return s=>s.type==="relative"?{type:"relative",path:o+s.path}:s}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:m}).strict(),et=a.omit({version:!0});function ot(e,o){return e===void 0&&o===void 0?!0:e===void 0||o===void 0?!1:e.name===o.name&&e.organization===o.organization&&e.version===o.version}function nt(e,o){return e===void 0&&o===void 0?!0:e===void 0||o===void 0?!1:e.name===o.name&&e.organization===o.organization}function y(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function x(e){return t.z.union([e.transform(o=>({type:"workflow-v1",main:o})).pipe(y(e)),t.z.discriminatedUnion("type",[y(e)])])}function p(e,o){return t.z.object({workflow:x(e),model:e,ui:o})}const g=p(t.z.string(),t.z.string());function it(e){return p(d.transform(k(e)),d.transform(k(e)))}function z(e,o){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:o.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:o.optional()}),marketplaceRanking:t.z.number().optional()})}const u=z(h,A),rt=z(t.z.string(),i),j=z(t.z.string(),C),st=t.z.object({components:g,meta:u});function f(e,o){return t.z.object({id:a,components:e,meta:o})}const ct=f(g,u),w=p(n,n),M=z(R,d),S=f(w,M),D=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),U=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:D}),at=t.z.object({schema:t.z.literal("v2"),description:S,files:t.z.array(U)}),lt="manifest.json",E=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),V=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),L=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a}),T=t.z.discriminatedUnion("type",[E,V,F,L]),I=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),W=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),O=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),Z=t.z.discriminatedUnion("type",[W,O,I]),b=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:Z}),zt=t.z.array(b),q=t.z.object({registryId:t.z.string(),id:a,meta:j,spec:T,otherVersions:t.z.array(m)}),N=b.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),dt=t.z.object({registries:t.z.array(N),blockPacks:t.z.array(q)}),pt=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=p;exports.BlockComponentsAbsoluteUrl=it;exports.BlockComponentsDescriptionRaw=g;exports.BlockComponentsManifest=w;exports.BlockPackDescriptionFromPackageJsonRaw=st;exports.BlockPackDescriptionManifest=S;exports.BlockPackDescriptionRaw=ct;exports.BlockPackDevV1=E;exports.BlockPackDevV2=V;exports.BlockPackFromRegistryV1=F;exports.BlockPackFromRegistryV2=L;exports.BlockPackId=a;exports.BlockPackIdNoVersion=et;exports.BlockPackListing=dt;exports.BlockPackManifest=at;exports.BlockPackManifestFile=lt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=u;exports.BlockPackMetaEmbeddedBase64=rt;exports.BlockPackMetaEmbeddedBytes=j;exports.BlockPackMetaManifest=M;exports.BlockPackOverview=q;exports.BlockPackSpec=T;exports.ContentAbsoluteBinaryLocal=Q;exports.ContentAbsoluteBinaryRemote=K;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=_;exports.ContentAbsoluteTextLocal=Y;exports.ContentAbsoluteTextRemote=X;exports.ContentAbsoluteUrl=l;exports.ContentAny=$;exports.ContentAnyBinaryLocal=P;exports.ContentAnyLocal=G;exports.ContentAnyRemote=H;exports.ContentAnyTextLocal=v;exports.ContentExplicitBase64=i;exports.ContentExplicitBytes=C;exports.ContentExplicitOrRelative=J;exports.ContentExplicitString=r;exports.ContentRelative=n;exports.ContentRelativeBinary=d;exports.ContentRelativeText=R;exports.CreateBlockPackDescriptionSchema=f;exports.DescriptionContentBinary=A;exports.DescriptionContentText=h;exports.LocalDevFolder=I;exports.ManifestFileInfo=U;exports.PFrameInternal=pt;exports.RegistryEntry=b;exports.RegistryList=zt;exports.RegistrySpec=Z;exports.RegistryStatus=N;exports.RemoteRegistryV1Spec=W;exports.RemoteRegistryV2Spec=O;exports.SemVer=m;exports.Sha256Schema=D;exports.Workflow=x;exports.WorkflowV1=y;exports.addPrefixToRelative=tt;exports.blockPackIdEquals=ot;exports.blockPackIdNoVersionEquals=nt;exports.mapRemoteToAbsolute=k;
|
|
2
2
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.js","sources":["../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":["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 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}\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';\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","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';\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 files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\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});\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 { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { 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 BlockPackOverview = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\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"],"names":["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","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"index.js","sources":["../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":["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 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 // The order of blocks on the \"marketplace\" (descending from highest to lowest). Not existent means `0`\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';\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","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';\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 files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\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});\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 { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { 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 BlockPackOverview = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\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"],"names":["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","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
|
package/dist/index.mjs
CHANGED
|
@@ -67,10 +67,10 @@ const r = t.object({
|
|
|
67
67
|
]), p = t.discriminatedUnion("type", [
|
|
68
68
|
i,
|
|
69
69
|
o
|
|
70
|
-
]),
|
|
70
|
+
]), R = t.discriminatedUnion("type", [
|
|
71
71
|
r,
|
|
72
72
|
o
|
|
73
|
-
]),
|
|
73
|
+
]), C = t.union([
|
|
74
74
|
t.string().startsWith("file:").transform((e, n) => ({ type: "relative", path: e.slice(5) })),
|
|
75
75
|
j
|
|
76
76
|
]), A = t.union([
|
|
@@ -145,12 +145,14 @@ function d(e, n) {
|
|
|
145
145
|
name: t.string(),
|
|
146
146
|
url: t.string().url(),
|
|
147
147
|
logo: n.optional()
|
|
148
|
-
})
|
|
148
|
+
}),
|
|
149
|
+
// The order of blocks on the "marketplace" (descending from highest to lowest). Not existent means `0`
|
|
150
|
+
marketplaceRanking: t.number().optional()
|
|
149
151
|
});
|
|
150
152
|
}
|
|
151
153
|
const b = d(
|
|
152
154
|
A,
|
|
153
|
-
|
|
155
|
+
C
|
|
154
156
|
), st = d(
|
|
155
157
|
t.string(),
|
|
156
158
|
i
|
|
@@ -171,7 +173,7 @@ function v(e, n) {
|
|
|
171
173
|
const at = v(
|
|
172
174
|
k,
|
|
173
175
|
b
|
|
174
|
-
), U = g(o, o), M = d(
|
|
176
|
+
), U = g(o, o), M = d(R, p), z = v(
|
|
175
177
|
U,
|
|
176
178
|
M
|
|
177
179
|
), S = t.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64), D = t.object({
|
|
@@ -276,9 +278,9 @@ export {
|
|
|
276
278
|
r as ContentExplicitString,
|
|
277
279
|
o as ContentRelative,
|
|
278
280
|
p as ContentRelativeBinary,
|
|
279
|
-
|
|
281
|
+
R as ContentRelativeText,
|
|
280
282
|
v as CreateBlockPackDescriptionSchema,
|
|
281
|
-
|
|
283
|
+
C as DescriptionContentBinary,
|
|
282
284
|
A as DescriptionContentText,
|
|
283
285
|
W as LocalDevFolder,
|
|
284
286
|
D as ManifestFileInfo,
|
package/dist/index.mjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.mjs","sources":["../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":["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 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}\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';\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","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';\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 files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\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});\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 { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { 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 BlockPackOverview = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\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"],"names":["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","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"index.mjs","sources":["../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":["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 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 // The order of blocks on the \"marketplace\" (descending from highest to lowest). Not existent means `0`\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';\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","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';\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 files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\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});\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 { BlockPackId, BlockPackMetaEmbeddedBytes, SemVer } from '../block_meta';\nimport { 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 BlockPackOverview = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\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"],"names":["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","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverview","RegistryStatus","BlockPackListing"],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@milaboratories/pl-model-middle-layer",
|
|
3
|
-
"version": "1.5.
|
|
3
|
+
"version": "1.5.8",
|
|
4
4
|
"description": "Common model between middle layer and non-block UI code",
|
|
5
5
|
"types": "./dist/index.d.ts",
|
|
6
6
|
"main": "./dist/index.js",
|
|
@@ -19,7 +19,7 @@
|
|
|
19
19
|
"dependencies": {
|
|
20
20
|
"zod": "^3.23.8",
|
|
21
21
|
"utility-types": "^3.11.0",
|
|
22
|
-
"@milaboratories/pl-model-common": "^1.6.
|
|
22
|
+
"@milaboratories/pl-model-common": "^1.6.1"
|
|
23
23
|
},
|
|
24
24
|
"devDependencies": {
|
|
25
25
|
"typescript": "~5.5.4",
|
|
@@ -24,7 +24,9 @@ export function BlockPackMeta<
|
|
|
24
24
|
name: z.string(),
|
|
25
25
|
url: z.string().url(),
|
|
26
26
|
logo: binary.optional()
|
|
27
|
-
})
|
|
27
|
+
}),
|
|
28
|
+
// The order of blocks on the "marketplace" (descending from highest to lowest). Not existent means `0`
|
|
29
|
+
marketplaceRanking: z.number().optional(),
|
|
28
30
|
});
|
|
29
31
|
}
|
|
30
32
|
|