@milaboratories/pl-model-middle-layer 1.6.2 → 1.6.4

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.
Files changed (16) hide show
  1. package/dist/block_registry/overview.d.ts.map +1 -1
  2. package/dist/index.js +1 -1
  3. package/dist/index.js.map +1 -1
  4. package/dist/index.mjs +25 -24
  5. package/dist/index.mjs.map +1 -1
  6. package/dist/pframe/internal_api/api_read.d.ts +1 -23
  7. package/dist/pframe/internal_api/api_read.d.ts.map +1 -1
  8. package/dist/pframe/internal_api/pframe.d.ts +1 -3
  9. package/dist/pframe/internal_api/pframe.d.ts.map +1 -1
  10. package/dist/pframe/internal_api/table.d.ts +0 -35
  11. package/dist/pframe/internal_api/table.d.ts.map +1 -1
  12. package/package.json +1 -1
  13. package/src/block_registry/overview.ts +3 -2
  14. package/src/pframe/internal_api/api_read.ts +1 -29
  15. package/src/pframe/internal_api/pframe.ts +1 -4
  16. package/src/pframe/internal_api/table.ts +0 -41
package/dist/block_registry/overview.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"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"}
1
+ {"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/block_registry/overview.ts"],"names":[],"mappings":"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"}
package/dist/index.js CHANGED
@@ -1,2 +1,2 @@
1
- "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),X=require("remeda");function Y(e){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const o in e)if(o!=="default"){const l=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(n,o,l.get?l:{enumerable:!0,get:()=>e[o]})}}return n.default=e,Object.freeze(n)}const h=Y(X),s=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),r=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),i=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),R=new RegExp("^(/|[A-Z]:\\\\)"),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(R,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),d=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),A=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),tt=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(R,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),et=t.z.discriminatedUnion("type",[s,r,i,c,d]),nt=t.z.discriminatedUnion("type",[s,r,i]),ot=t.z.discriminatedUnion("type",[s,r,i,c]),it=t.z.discriminatedUnion("type",[s,r,i,d]),j=t.z.discriminatedUnion("type",[r,i,c]),w=t.z.discriminatedUnion("type",[s,i,c]),rt=t.z.discriminatedUnion("type",[r,d]),st=t.z.discriminatedUnion("type",[r,c]),ct=t.z.discriminatedUnion("type",[s,d]),at=t.z.discriminatedUnion("type",[s,c]),k=t.z.discriminatedUnion("type",[r,i]),x=t.z.discriminatedUnion("type",[s,i]),S=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),j]),V=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),w]),g=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 u(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"absolute-url",url:n+o.path}:o}function lt(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"relative",path:n+o.path}:o}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:g}).strict(),M=a.omit({version:!0});function dt(e){if(e!==void 0)return`${e.organization}:${e.name}:${e.version}`}function zt(e){if(e!==void 0)return`${e.organization}:${e.name}`}function kt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization&&e.version===n.version}function gt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization}function y(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function D(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(y(e)),t.z.discriminatedUnion("type",[y(e)])])}function p(e,n){return t.z.object({workflow:D(e),model:e,ui:n})}const f=p(t.z.string(),t.z.string());function pt(e){return p(k.transform(u(e)),k.transform(u(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()}),marketplaceRanking:t.z.number().optional()})}const b=z(V,S),ut=z(t.z.string(),r),v=z(t.z.string(),A),yt=t.z.object({components:f,meta:b});function B(e,n){return t.z.object({id:a,components:e,meta:n})}const mt=B(f,b);function ft(e,n){return h.mergeDeep(e,{id:{version:n}})}const T=p(i,i),U=z(x,k),E=B(T,U),I=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),L=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:I}),bt=t.z.object({schema:t.z.literal("v2"),description:E,timestamp:t.z.number().optional(),files:t.z.array(L)}),vt="manifest.json";function Bt(e,n){return h.mergeDeep(e,{description:{id:{version:n}}})}const O=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),W=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),$=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a,channel:t.z.string().optional()}),P=t.z.discriminatedUnion("type",[O,F,W,$]),q=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),N=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),Z=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),_=t.z.discriminatedUnion("type",[N,Z,q]),C=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:_}),Pt=t.z.array(C),Ct=t.z.object({registryId:t.z.string(),id:a,meta:v,spec:P,otherVersions:t.z.array(g)}),J="any",m="stable",G=t.z.object({version:g,channels:t.z.array(t.z.string())}),H=t.z.object({id:a,meta:v,spec:P}),K=t.z.object({id:M,latestByChannel:t.z.record(t.z.string(),H),allVersions:t.z.array(G),registryId:t.z.string()}),Q=C.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),ht=t.z.object({registries:t.z.array(Q),blockPacks:t.z.array(K)});function Rt(e){const n=e.latestByChannel[m]!==void 0?m:J,o=e.latestByChannel[n];return{id:o.id,meta:o.meta,spec:o.spec,otherVersions:e.allVersions.filter(l=>l.channels.indexOf(n)>=0).map(l=>l.version),registryId:e.registryId}}const At=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.AnyChannel=J;exports.BlockComponents=p;exports.BlockComponentsAbsoluteUrl=pt;exports.BlockComponentsDescriptionRaw=f;exports.BlockComponentsManifest=T;exports.BlockPackDescriptionFromPackageJsonRaw=yt;exports.BlockPackDescriptionManifest=E;exports.BlockPackDescriptionRaw=mt;exports.BlockPackDevV1=O;exports.BlockPackDevV2=F;exports.BlockPackFromRegistryV1=W;exports.BlockPackFromRegistryV2=$;exports.BlockPackId=a;exports.BlockPackIdNoVersion=M;exports.BlockPackListing=ht;exports.BlockPackManifest=bt;exports.BlockPackManifestFile=vt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=b;exports.BlockPackMetaEmbeddedBase64=ut;exports.BlockPackMetaEmbeddedBytes=v;exports.BlockPackMetaManifest=U;exports.BlockPackOverview=K;exports.BlockPackOverviewLegacy=Ct;exports.BlockPackSpec=P;exports.ContentAbsoluteBinaryLocal=st;exports.ContentAbsoluteBinaryRemote=rt;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=tt;exports.ContentAbsoluteTextLocal=at;exports.ContentAbsoluteTextRemote=ct;exports.ContentAbsoluteUrl=d;exports.ContentAny=et;exports.ContentAnyBinaryLocal=j;exports.ContentAnyLocal=ot;exports.ContentAnyRemote=it;exports.ContentAnyTextLocal=w;exports.ContentExplicitBase64=r;exports.ContentExplicitBytes=A;exports.ContentExplicitOrRelative=nt;exports.ContentExplicitString=s;exports.ContentRelative=i;exports.ContentRelativeBinary=k;exports.ContentRelativeText=x;exports.CreateBlockPackDescriptionSchema=B;exports.DescriptionContentBinary=S;exports.DescriptionContentText=V;exports.LocalDevFolder=q;exports.ManifestFileInfo=L;exports.PFrameInternal=At;exports.RegistryEntry=C;exports.RegistryList=Pt;exports.RegistrySpec=_;exports.RegistryStatus=Q;exports.RemoteRegistryV1Spec=N;exports.RemoteRegistryV2Spec=Z;exports.SemVer=g;exports.Sha256Schema=I;exports.SingleBlockPackOverview=H;exports.StableChannel=m;exports.VersionWithChannels=G;exports.Workflow=D;exports.WorkflowV1=y;exports.addPrefixToRelative=lt;exports.blockPackIdEquals=kt;exports.blockPackIdNoVersionEquals=gt;exports.blockPackIdNoVersionToString=zt;exports.blockPackIdToString=dt;exports.blockPackOverviewToLegacy=Rt;exports.mapRemoteToAbsolute=u;exports.overrideDescriptionVersion=ft;exports.overrideManifestVersion=Bt;
1
+ "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),X=require("remeda");function Y(e){const n=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const o in e)if(o!=="default"){const l=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(n,o,l.get?l:{enumerable:!0,get:()=>e[o]})}}return n.default=e,Object.freeze(n)}const h=Y(X),c=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),r=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),i=t.z.object({type:t.z.literal("relative"),path:t.z.string().describe("Address of the file, in most cases relative to the file which this structure is a part of")}).strict(),R=new RegExp("^(/|[A-Z]:\\\\)"),s=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().regex(R,"path to file must be absolute").describe("Absolute address of the file in local file system")}).strict(),d=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),A=t.z.object({type:t.z.literal("explicit-bytes"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),tt=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().regex(R,"path to folder must be absolute").describe("Absolute address of the folder in local file system")}).strict(),et=t.z.discriminatedUnion("type",[c,r,i,s,d]),nt=t.z.discriminatedUnion("type",[c,r,i]),ot=t.z.discriminatedUnion("type",[c,r,i,s]),it=t.z.discriminatedUnion("type",[c,r,i,d]),j=t.z.discriminatedUnion("type",[r,i,s]),w=t.z.discriminatedUnion("type",[c,i,s]),rt=t.z.discriminatedUnion("type",[r,d]),ct=t.z.discriminatedUnion("type",[r,s]),st=t.z.discriminatedUnion("type",[c,d]),at=t.z.discriminatedUnion("type",[c,s]),g=t.z.discriminatedUnion("type",[r,i]),x=t.z.discriminatedUnion("type",[c,i]),S=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),j]),V=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),w]),p=t.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,"Wrong version format, please use valid semver");function y(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"absolute-url",url:n+o.path}:o}function lt(e){const n=e.endsWith("/")?e:`${e}/`;return o=>o.type==="relative"?{type:"relative",path:n+o.path}:o}const a=t.z.object({organization:t.z.string(),name:t.z.string(),version:p}).strict(),M=a.omit({version:!0});function dt(e){if(e!==void 0)return`${e.organization}:${e.name}:${e.version}`}function zt(e){if(e!==void 0)return`${e.organization}:${e.name}`}function kt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization&&e.version===n.version}function gt(e,n){return e===void 0&&n===void 0?!0:e===void 0||n===void 0?!1:e.name===n.name&&e.organization===n.organization}function m(e){return t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})}function D(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})).pipe(m(e)),t.z.discriminatedUnion("type",[m(e)])])}function u(e,n){return t.z.object({workflow:D(e),model:e,ui:n})}const f=u(t.z.string(),t.z.string());function pt(e){return u(g.transform(y(e)),g.transform(y(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription:e.optional(),changelog:e.optional(),logo:n.optional(),url:t.z.string().url().optional(),docs:t.z.string().url().optional(),support:t.z.union([t.z.string().url(),t.z.string().email()]).optional(),tags:t.z.array(t.z.string()).optional(),organization:t.z.object({name:t.z.string(),url:t.z.string().url(),logo:n.optional()}),marketplaceRanking:t.z.number().optional()})}const b=z(V,S),ut=z(t.z.string(),r),v=z(t.z.string(),A),yt=t.z.object({components:f,meta:b});function B(e,n){return t.z.object({id:a,components:e,meta:n})}const mt=B(f,b);function ft(e,n){return h.mergeDeep(e,{id:{version:n}})}const T=u(i,i),U=z(x,g),E=B(T,U),I=t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64),L=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:I}),bt=t.z.object({schema:t.z.literal("v2"),description:E,timestamp:t.z.number().optional(),files:t.z.array(L)}),vt="manifest.json";function Bt(e,n){return h.mergeDeep(e,{description:{id:{version:n}}})}const O=t.z.object({type:t.z.literal("dev-v1"),folder:t.z.string(),mtime:t.z.string().optional()}),F=t.z.object({type:t.z.literal("dev-v2"),folder:t.z.string(),mtime:t.z.string().optional()}),W=t.z.object({type:t.z.literal("from-registry-v1"),registryUrl:t.z.string(),id:a}),$=t.z.object({type:t.z.literal("from-registry-v2"),registryUrl:t.z.string(),id:a,channel:t.z.string().optional()}),P=t.z.discriminatedUnion("type",[O,F,W,$]),q=t.z.object({type:t.z.literal("local-dev"),path:t.z.string()}),N=t.z.object({type:t.z.literal("remote-v1"),url:t.z.string().url()}),Z=t.z.object({type:t.z.literal("remote-v2"),url:t.z.string().url()}),_=t.z.discriminatedUnion("type",[N,Z,q]),C=t.z.object({id:t.z.string(),title:t.z.string().optional(),spec:_}),Pt=t.z.array(C),Ct=t.z.object({registryId:t.z.string(),id:a,meta:v,spec:P,otherVersions:t.z.array(p)}),J="any",k="stable",G=t.z.object({version:p,channels:t.z.array(t.z.string())}),H=t.z.object({id:a,meta:v,spec:P}),K=t.z.object({id:M,latestByChannel:t.z.record(t.z.string(),H),allVersions:t.z.array(G),registryId:t.z.string()}),Q=C.extend({status:t.z.union([t.z.literal("online"),t.z.literal("offline")])}),ht=t.z.object({registries:t.z.array(Q),blockPacks:t.z.array(K)});function Rt(e){const n=e.latestByChannel[k]!==void 0?k:J,o=e.latestByChannel[n];return{id:o.id,meta:o.meta,spec:{...o.spec,channel:k},otherVersions:e.allVersions.filter(l=>l.channels.indexOf(n)>=0).map(l=>l.version),registryId:e.registryId}}const At=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.AnyChannel=J;exports.BlockComponents=u;exports.BlockComponentsAbsoluteUrl=pt;exports.BlockComponentsDescriptionRaw=f;exports.BlockComponentsManifest=T;exports.BlockPackDescriptionFromPackageJsonRaw=yt;exports.BlockPackDescriptionManifest=E;exports.BlockPackDescriptionRaw=mt;exports.BlockPackDevV1=O;exports.BlockPackDevV2=F;exports.BlockPackFromRegistryV1=W;exports.BlockPackFromRegistryV2=$;exports.BlockPackId=a;exports.BlockPackIdNoVersion=M;exports.BlockPackListing=ht;exports.BlockPackManifest=bt;exports.BlockPackManifestFile=vt;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=b;exports.BlockPackMetaEmbeddedBase64=ut;exports.BlockPackMetaEmbeddedBytes=v;exports.BlockPackMetaManifest=U;exports.BlockPackOverview=K;exports.BlockPackOverviewLegacy=Ct;exports.BlockPackSpec=P;exports.ContentAbsoluteBinaryLocal=ct;exports.ContentAbsoluteBinaryRemote=rt;exports.ContentAbsoluteFile=s;exports.ContentAbsoluteFolder=tt;exports.ContentAbsoluteTextLocal=at;exports.ContentAbsoluteTextRemote=st;exports.ContentAbsoluteUrl=d;exports.ContentAny=et;exports.ContentAnyBinaryLocal=j;exports.ContentAnyLocal=ot;exports.ContentAnyRemote=it;exports.ContentAnyTextLocal=w;exports.ContentExplicitBase64=r;exports.ContentExplicitBytes=A;exports.ContentExplicitOrRelative=nt;exports.ContentExplicitString=c;exports.ContentRelative=i;exports.ContentRelativeBinary=g;exports.ContentRelativeText=x;exports.CreateBlockPackDescriptionSchema=B;exports.DescriptionContentBinary=S;exports.DescriptionContentText=V;exports.LocalDevFolder=q;exports.ManifestFileInfo=L;exports.PFrameInternal=At;exports.RegistryEntry=C;exports.RegistryList=Pt;exports.RegistrySpec=_;exports.RegistryStatus=Q;exports.RemoteRegistryV1Spec=N;exports.RemoteRegistryV2Spec=Z;exports.SemVer=p;exports.Sha256Schema=I;exports.SingleBlockPackOverview=H;exports.StableChannel=k;exports.VersionWithChannels=G;exports.Workflow=D;exports.WorkflowV1=m;exports.addPrefixToRelative=lt;exports.blockPackIdEquals=kt;exports.blockPackIdNoVersionEquals=gt;exports.blockPackIdNoVersionToString=zt;exports.blockPackIdToString=dt;exports.blockPackOverviewToLegacy=Rt;exports.mapRemoteToAbsolute=y;exports.overrideDescriptionVersion=ft;exports.overrideManifestVersion=Bt;
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 blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n bp1: BlockPackId | undefined,\n bp2: BlockPackId | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return (\n bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n );\n}\n\nexport function blockPackIdNoVersionEquals(\n bp1: BlockPackIdNoVersion | undefined,\n bp2: BlockPackIdNoVersion | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.object({\n type: z.literal('workflow-v1'),\n main: contentType.describe('Main workflow')\n });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.union([\n // string is converted to v1 workflow\n contentType\n .transform((value: z.infer<typeof contentType>) => ({\n type: 'workflow-v1' as const,\n main: value\n }))\n .pipe(WorkflowV1(contentType)),\n // structured objects are decoded as union with type descriptor\n z.discriminatedUnion('type', [WorkflowV1(contentType)])\n ]);\n}\n\nexport function BlockComponents<\n const WfAndModel extends z.ZodTypeAny,\n const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n return z.object({\n workflow: Workflow(wfAndModel),\n model: wfAndModel,\n ui\n });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n return BlockComponents(\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n ContentExplicitBase64,\n ContentExplicitBytes,\n DescriptionContentBinary,\n DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n const LongStringType extends z.ZodTypeAny,\n const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n return z.object({\n title: z.string(),\n description: z.string(),\n longDescription: longString.optional(),\n changelog: longString.optional(),\n logo: binary.optional(),\n url: z.string().url().optional(),\n docs: z.string().url().optional(),\n support: z.union([z.string().url(), z.string().email()]).optional(),\n tags: z.array(z.string()).optional(),\n organization: z.object({\n name: z.string(),\n url: z.string().url(),\n logo: binary.optional()\n }),\n /**\n * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n * `undefined` value or absent field is treated exactly the same as number `0`.\n */\n marketplaceRanking: z.number().optional(),\n });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n DescriptionContentText,\n DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n z.string(),\n ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n z.string(),\n ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n components: BlockComponentsDescriptionRaw,\n meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n Components extends ZodTypeAny,\n Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n return z.object({\n id: BlockPackId,\n components,\n meta\n });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n BlockComponentsDescriptionRaw,\n BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n BlockComponentsManifest,\n BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n .string()\n .regex(/[0-9a-fA-F]/)\n .toUpperCase()\n .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n name: z.string(),\n size: z.number().int(),\n sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n schema: z.literal('v2'),\n description: BlockPackDescriptionManifest,\n timestamp: z.number().optional(),\n files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n type: z.literal('dev-v1'),\n folder: z.string(),\n mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n type: z.literal('dev-v2'),\n folder: z.string(),\n mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n type: z.literal('from-registry-v1'),\n registryUrl: z.string(),\n id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n type: z.literal('from-registry-v2'),\n registryUrl: z.string(),\n id: BlockPackId,\n channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n BlockPackDevV1,\n BlockPackDevV2,\n BlockPackFromRegistryV1,\n BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n type: z.literal('local-dev'),\n path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n type: z.literal('remote-v1'),\n url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n type: z.literal('remote-v2'),\n url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n RemoteRegistryV1Spec,\n RemoteRegistryV2Spec,\n LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n id: z.string(),\n title: z.string().optional(),\n spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n BlockPackId,\n BlockPackIdNoVersion,\n BlockPackMetaEmbeddedBytes,\n SemVer\n} from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n version: SemVer,\n channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n id: BlockPackIdNoVersion,\n latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n allVersions: z.array(VersionWithChannels),\n registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n registries: z.array(RegistryStatus),\n blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n const latestOverview = bpo.latestByChannel[mainChannel];\n return {\n id: latestOverview.id,\n meta: latestOverview.meta,\n spec: latestOverview.spec,\n otherVersions: bpo.allVersions\n .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n .map((v) => v.version),\n registryId: bpo.registryId\n };\n}\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
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 blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n bp1: BlockPackId | undefined,\n bp2: BlockPackId | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return (\n bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n );\n}\n\nexport function blockPackIdNoVersionEquals(\n bp1: BlockPackIdNoVersion | undefined,\n bp2: BlockPackIdNoVersion | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.object({\n type: z.literal('workflow-v1'),\n main: contentType.describe('Main workflow')\n });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.union([\n // string is converted to v1 workflow\n contentType\n .transform((value: z.infer<typeof contentType>) => ({\n type: 'workflow-v1' as const,\n main: value\n }))\n .pipe(WorkflowV1(contentType)),\n // structured objects are decoded as union with type descriptor\n z.discriminatedUnion('type', [WorkflowV1(contentType)])\n ]);\n}\n\nexport function BlockComponents<\n const WfAndModel extends z.ZodTypeAny,\n const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n return z.object({\n workflow: Workflow(wfAndModel),\n model: wfAndModel,\n ui\n });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n return BlockComponents(\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n ContentExplicitBase64,\n ContentExplicitBytes,\n DescriptionContentBinary,\n DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n const LongStringType extends z.ZodTypeAny,\n const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n return z.object({\n title: z.string(),\n description: z.string(),\n longDescription: longString.optional(),\n changelog: longString.optional(),\n logo: binary.optional(),\n url: z.string().url().optional(),\n docs: z.string().url().optional(),\n support: z.union([z.string().url(), z.string().email()]).optional(),\n tags: z.array(z.string()).optional(),\n organization: z.object({\n name: z.string(),\n url: z.string().url(),\n logo: binary.optional()\n }),\n /**\n * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n * `undefined` value or absent field is treated exactly the same as number `0`.\n */\n marketplaceRanking: z.number().optional(),\n });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n DescriptionContentText,\n DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n z.string(),\n ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n z.string(),\n ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n components: BlockComponentsDescriptionRaw,\n meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n Components extends ZodTypeAny,\n Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n return z.object({\n id: BlockPackId,\n components,\n meta\n });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n BlockComponentsDescriptionRaw,\n BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n BlockComponentsManifest,\n BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n .string()\n .regex(/[0-9a-fA-F]/)\n .toUpperCase()\n .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n name: z.string(),\n size: z.number().int(),\n sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n schema: z.literal('v2'),\n description: BlockPackDescriptionManifest,\n timestamp: z.number().optional(),\n files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n type: z.literal('dev-v1'),\n folder: z.string(),\n mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n type: z.literal('dev-v2'),\n folder: z.string(),\n mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n type: z.literal('from-registry-v1'),\n registryUrl: z.string(),\n id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n type: z.literal('from-registry-v2'),\n registryUrl: z.string(),\n id: BlockPackId,\n channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n BlockPackDevV1,\n BlockPackDevV2,\n BlockPackFromRegistryV1,\n BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n type: z.literal('local-dev'),\n path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n type: z.literal('remote-v1'),\n url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n type: z.literal('remote-v2'),\n url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n RemoteRegistryV1Spec,\n RemoteRegistryV2Spec,\n LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n id: z.string(),\n title: z.string().optional(),\n spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n BlockPackId,\n BlockPackIdNoVersion,\n BlockPackMetaEmbeddedBytes,\n SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n version: SemVer,\n channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n id: BlockPackIdNoVersion,\n latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n allVersions: z.array(VersionWithChannels),\n registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n registries: z.array(RegistryStatus),\n blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n const latestOverview = bpo.latestByChannel[mainChannel];\n return {\n id: latestOverview.id,\n meta: latestOverview.meta,\n // so we only add stable channel specs to projects, to smooth the transition\n spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n otherVersions: bpo.allVersions\n .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n .map((v) => v.version),\n registryId: bpo.registryId\n };\n}\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
package/dist/index.mjs CHANGED
@@ -65,7 +65,7 @@ const s = t.object({
65
65
  ]), ct = t.discriminatedUnion("type", [
66
66
  s,
67
67
  c
68
- ]), m = t.discriminatedUnion("type", [
68
+ ]), p = t.discriminatedUnion("type", [
69
69
  r,
70
70
  o
71
71
  ]), U = t.discriminatedUnion("type", [
@@ -77,11 +77,11 @@ const s = t.object({
77
77
  ]), z = t.union([
78
78
  t.string().transform((e, n) => e.startsWith("file:") ? { type: "relative", path: e.slice(5) } : { type: "explicit-string", content: e }),
79
79
  w
80
- ]), p = t.string().regex(
80
+ ]), u = t.string().regex(
81
81
  /^(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-]+)*))?$/,
82
82
  "Wrong version format, please use valid semver"
83
83
  );
84
- function y(e) {
84
+ function f(e) {
85
85
  const n = e.endsWith("/") ? e : `${e}/`;
86
86
  return (i) => i.type === "relative" ? { type: "absolute-url", url: n + i.path } : i;
87
87
  }
@@ -92,7 +92,7 @@ function at(e) {
92
92
  const a = t.object({
93
93
  organization: t.string(),
94
94
  name: t.string(),
95
- version: p
95
+ version: u
96
96
  }).strict(), M = a.omit({ version: !0 });
97
97
  function lt(e) {
98
98
  if (e !== void 0)
@@ -108,7 +108,7 @@ function gt(e, n) {
108
108
  function mt(e, n) {
109
109
  return e === void 0 && n === void 0 ? !0 : e === void 0 || n === void 0 ? !1 : e.name === n.name && e.organization === n.organization;
110
110
  }
111
- function f(e) {
111
+ function k(e) {
112
112
  return t.object({
113
113
  type: t.literal("workflow-v1"),
114
114
  main: e.describe("Main workflow")
@@ -120,23 +120,23 @@ function S(e) {
120
120
  e.transform((n) => ({
121
121
  type: "workflow-v1",
122
122
  main: n
123
- })).pipe(f(e)),
123
+ })).pipe(k(e)),
124
124
  // structured objects are decoded as union with type descriptor
125
- t.discriminatedUnion("type", [f(e)])
125
+ t.discriminatedUnion("type", [k(e)])
126
126
  ]);
127
127
  }
128
- function u(e, n) {
128
+ function y(e, n) {
129
129
  return t.object({
130
130
  workflow: S(e),
131
131
  model: e,
132
132
  ui: n
133
133
  });
134
134
  }
135
- const h = u(t.string(), t.string());
135
+ const h = y(t.string(), t.string());
136
136
  function pt(e) {
137
- return u(
138
- m.transform(y(e)),
139
- m.transform(y(e))
137
+ return y(
138
+ p.transform(f(e)),
139
+ p.transform(f(e))
140
140
  );
141
141
  }
142
142
  function d(e, n) {
@@ -189,7 +189,7 @@ const ft = P(
189
189
  function kt(e, n) {
190
190
  return v.mergeDeep(e, { id: { version: n } });
191
191
  }
192
- const D = u(o, o), I = d(U, m), E = P(
192
+ const D = y(o, o), I = d(U, p), E = P(
193
193
  D,
194
194
  I
195
195
  ), L = t.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64), T = t.object({
@@ -249,9 +249,9 @@ const F = t.object({
249
249
  id: a,
250
250
  meta: C,
251
251
  spec: j,
252
- otherVersions: t.array(p)
253
- }), G = "any", k = "stable", J = t.object({
254
- version: p,
252
+ otherVersions: t.array(u)
253
+ }), G = "any", m = "stable", J = t.object({
254
+ version: u,
255
255
  channels: t.array(t.string())
256
256
  }), H = t.object({
257
257
  id: a,
@@ -269,11 +269,12 @@ const F = t.object({
269
269
  blockPacks: t.array(K)
270
270
  });
271
271
  function jt(e) {
272
- const n = e.latestByChannel[k] !== void 0 ? k : G, i = e.latestByChannel[n];
272
+ const n = e.latestByChannel[m] !== void 0 ? m : G, i = e.latestByChannel[n];
273
273
  return {
274
274
  id: i.id,
275
275
  meta: i.meta,
276
- spec: i.spec,
276
+ // so we only add stable channel specs to projects, to smooth the transition
277
+ spec: { ...i.spec, channel: m },
277
278
  otherVersions: e.allVersions.filter((g) => g.channels.indexOf(n) >= 0).map((g) => g.version),
278
279
  registryId: e.registryId
279
280
  };
@@ -283,7 +284,7 @@ const Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
283
284
  }, Symbol.toStringTag, { value: "Module" }));
284
285
  export {
285
286
  G as AnyChannel,
286
- u as BlockComponents,
287
+ y as BlockComponents,
287
288
  pt as BlockComponentsAbsoluteUrl,
288
289
  h as BlockComponentsDescriptionRaw,
289
290
  D as BlockComponentsManifest,
@@ -324,7 +325,7 @@ export {
324
325
  et as ContentExplicitOrRelative,
325
326
  s as ContentExplicitString,
326
327
  o as ContentRelative,
327
- m as ContentRelativeBinary,
328
+ p as ContentRelativeBinary,
328
329
  U as ContentRelativeText,
329
330
  P as CreateBlockPackDescriptionSchema,
330
331
  V as DescriptionContentBinary,
@@ -338,20 +339,20 @@ export {
338
339
  Q as RegistryStatus,
339
340
  _ as RemoteRegistryV1Spec,
340
341
  q as RemoteRegistryV2Spec,
341
- p as SemVer,
342
+ u as SemVer,
342
343
  L as Sha256Schema,
343
344
  H as SingleBlockPackOverview,
344
- k as StableChannel,
345
+ m as StableChannel,
345
346
  J as VersionWithChannels,
346
347
  S as Workflow,
347
- f as WorkflowV1,
348
+ k as WorkflowV1,
348
349
  at as addPrefixToRelative,
349
350
  gt as blockPackIdEquals,
350
351
  mt as blockPackIdNoVersionEquals,
351
352
  dt as blockPackIdNoVersionToString,
352
353
  lt as blockPackIdToString,
353
354
  jt as blockPackOverviewToLegacy,
354
- y as mapRemoteToAbsolute,
355
+ f as mapRemoteToAbsolute,
355
356
  kt as overrideDescriptionVersion,
356
357
  ht as overrideManifestVersion
357
358
  };
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 blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n bp1: BlockPackId | undefined,\n bp2: BlockPackId | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return (\n bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n );\n}\n\nexport function blockPackIdNoVersionEquals(\n bp1: BlockPackIdNoVersion | undefined,\n bp2: BlockPackIdNoVersion | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.object({\n type: z.literal('workflow-v1'),\n main: contentType.describe('Main workflow')\n });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.union([\n // string is converted to v1 workflow\n contentType\n .transform((value: z.infer<typeof contentType>) => ({\n type: 'workflow-v1' as const,\n main: value\n }))\n .pipe(WorkflowV1(contentType)),\n // structured objects are decoded as union with type descriptor\n z.discriminatedUnion('type', [WorkflowV1(contentType)])\n ]);\n}\n\nexport function BlockComponents<\n const WfAndModel extends z.ZodTypeAny,\n const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n return z.object({\n workflow: Workflow(wfAndModel),\n model: wfAndModel,\n ui\n });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n return BlockComponents(\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n ContentExplicitBase64,\n ContentExplicitBytes,\n DescriptionContentBinary,\n DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n const LongStringType extends z.ZodTypeAny,\n const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n return z.object({\n title: z.string(),\n description: z.string(),\n longDescription: longString.optional(),\n changelog: longString.optional(),\n logo: binary.optional(),\n url: z.string().url().optional(),\n docs: z.string().url().optional(),\n support: z.union([z.string().url(), z.string().email()]).optional(),\n tags: z.array(z.string()).optional(),\n organization: z.object({\n name: z.string(),\n url: z.string().url(),\n logo: binary.optional()\n }),\n /**\n * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n * `undefined` value or absent field is treated exactly the same as number `0`.\n */\n marketplaceRanking: z.number().optional(),\n });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n DescriptionContentText,\n DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n z.string(),\n ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n z.string(),\n ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n components: BlockComponentsDescriptionRaw,\n meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n Components extends ZodTypeAny,\n Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n return z.object({\n id: BlockPackId,\n components,\n meta\n });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n BlockComponentsDescriptionRaw,\n BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n BlockComponentsManifest,\n BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n .string()\n .regex(/[0-9a-fA-F]/)\n .toUpperCase()\n .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n name: z.string(),\n size: z.number().int(),\n sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n schema: z.literal('v2'),\n description: BlockPackDescriptionManifest,\n timestamp: z.number().optional(),\n files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n type: z.literal('dev-v1'),\n folder: z.string(),\n mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n type: z.literal('dev-v2'),\n folder: z.string(),\n mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n type: z.literal('from-registry-v1'),\n registryUrl: z.string(),\n id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n type: z.literal('from-registry-v2'),\n registryUrl: z.string(),\n id: BlockPackId,\n channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n BlockPackDevV1,\n BlockPackDevV2,\n BlockPackFromRegistryV1,\n BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n type: z.literal('local-dev'),\n path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n type: z.literal('remote-v1'),\n url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n type: z.literal('remote-v2'),\n url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n RemoteRegistryV1Spec,\n RemoteRegistryV2Spec,\n LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n id: z.string(),\n title: z.string().optional(),\n spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n BlockPackId,\n BlockPackIdNoVersion,\n BlockPackMetaEmbeddedBytes,\n SemVer\n} from '../block_meta';\nimport { BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n version: SemVer,\n channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n id: BlockPackIdNoVersion,\n latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n allVersions: z.array(VersionWithChannels),\n registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n registries: z.array(RegistryStatus),\n blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n const latestOverview = bpo.latestByChannel[mainChannel];\n return {\n id: latestOverview.id,\n meta: latestOverview.meta,\n spec: latestOverview.spec,\n otherVersions: bpo.allVersions\n .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n .map((v) => v.version),\n registryId: bpo.registryId\n };\n}\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
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 blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n if (bp === undefined) return undefined;\n return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n bp1: BlockPackId | undefined,\n bp2: BlockPackId | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return (\n bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n );\n}\n\nexport function blockPackIdNoVersionEquals(\n bp1: BlockPackIdNoVersion | undefined,\n bp2: BlockPackIdNoVersion | undefined\n): boolean {\n if (bp1 === undefined && bp2 === undefined) return true;\n if (bp1 === undefined || bp2 === undefined) return false;\n return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.object({\n type: z.literal('workflow-v1'),\n main: contentType.describe('Main workflow')\n });\n}\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n return z.union([\n // string is converted to v1 workflow\n contentType\n .transform((value: z.infer<typeof contentType>) => ({\n type: 'workflow-v1' as const,\n main: value\n }))\n .pipe(WorkflowV1(contentType)),\n // structured objects are decoded as union with type descriptor\n z.discriminatedUnion('type', [WorkflowV1(contentType)])\n ]);\n}\n\nexport function BlockComponents<\n const WfAndModel extends z.ZodTypeAny,\n const UI extends z.ZodTypeAny\n>(wfAndModel: WfAndModel, ui: UI) {\n return z.object({\n workflow: Workflow(wfAndModel),\n model: wfAndModel,\n ui\n });\n}\n\nexport const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());\nexport type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;\n\nexport function BlockComponentsAbsoluteUrl(prefix: string) {\n return BlockComponents(\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),\n ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))\n );\n}\nexport type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;\n\n// export const BlockComponentsExplicit = BlockComponents(, ContentRelative);\n// export type BlockComponentsExplicit = z.infer<typeof BlockComponentsExplicit>;\n","import { z } from 'zod';\nimport {\n ContentExplicitBase64,\n ContentExplicitBytes,\n DescriptionContentBinary,\n DescriptionContentText\n} from './content_types';\n\nexport function BlockPackMeta<\n const LongStringType extends z.ZodTypeAny,\n const BinaryType extends z.ZodTypeAny\n>(longString: LongStringType, binary: BinaryType) {\n return z.object({\n title: z.string(),\n description: z.string(),\n longDescription: longString.optional(),\n changelog: longString.optional(),\n logo: binary.optional(),\n url: z.string().url().optional(),\n docs: z.string().url().optional(),\n support: z.union([z.string().url(), z.string().email()]).optional(),\n tags: z.array(z.string()).optional(),\n organization: z.object({\n name: z.string(),\n url: z.string().url(),\n logo: binary.optional()\n }),\n /**\n * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n * `undefined` value or absent field is treated exactly the same as number `0`.\n */\n marketplaceRanking: z.number().optional(),\n });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n DescriptionContentText,\n DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n z.string(),\n ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n z.string(),\n ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n components: BlockComponentsDescriptionRaw,\n meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n Components extends ZodTypeAny,\n Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n return z.object({\n id: BlockPackId,\n components,\n meta\n });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n BlockComponentsDescriptionRaw,\n BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\nimport * as R from 'remeda';\nimport { BlockPackId } from './block_id';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n BlockComponentsManifest,\n BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n .string()\n .regex(/[0-9a-fA-F]/)\n .toUpperCase()\n .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n name: z.string(),\n size: z.number().int(),\n sha256: Sha256Schema\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n schema: z.literal('v2'),\n description: BlockPackDescriptionManifest,\n timestamp: z.number().optional(),\n files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n manifest: T,\n newVersion: string\n): T {\n return R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n","import { z } from 'zod';\nimport { BlockPackId } from '../block_meta';\n\n/** Block pack from local folder, to be used during block development. Old layout.\n * @deprecated don't use */\nexport const BlockPackDevV1 = z.object({\n type: z.literal('dev-v1'),\n folder: z.string(),\n mtime: z.string().optional()\n});\n/** @deprecated don't use */\nexport type BlockPackDevV1 = z.infer<typeof BlockPackDevV1>;\n\n/** Block pack from local folder, to be used during block development. New layout. */\nexport const BlockPackDevV2 = z.object({\n type: z.literal('dev-v2'),\n folder: z.string(),\n mtime: z.string().optional()\n});\nexport type BlockPackDevV2 = z.infer<typeof BlockPackDevV2>;\n\n/**\n * Block pack from registry with version 2 layout, to be loaded directly\n * from the client.\n * @deprecated don't use\n * */\nexport const BlockPackFromRegistryV1 = z.object({\n type: z.literal('from-registry-v1'),\n registryUrl: z.string(),\n id: BlockPackId\n});\n/** @deprecated don't use */\nexport type BlockPackFromRegistryV1 = z.infer<typeof BlockPackFromRegistryV1>;\n\n/** Block pack from registry with version 2 layout, to be loaded directly\n * from the client. */\nexport const BlockPackFromRegistryV2 = z.object({\n type: z.literal('from-registry-v2'),\n registryUrl: z.string(),\n id: BlockPackId,\n channel: z.string().optional()\n});\nexport type BlockPackFromRegistryV2 = z.infer<typeof BlockPackFromRegistryV2>;\n\n/** Information about block origin, can be used to instantiate new blocks */\nexport const BlockPackSpec = z.discriminatedUnion('type', [\n BlockPackDevV1,\n BlockPackDevV2,\n BlockPackFromRegistryV1,\n BlockPackFromRegistryV2\n]);\nexport type BlockPackSpec = z.infer<typeof BlockPackSpec>;\n","import { z } from 'zod';\n\nexport const LocalDevFolder = z.object({\n type: z.literal('local-dev'),\n path: z.string()\n});\nexport type LocalDevFolder = z.infer<typeof LocalDevFolder>;\n\n/** @deprecated don't use */\nexport const RemoteRegistryV1Spec = z.object({\n type: z.literal('remote-v1'),\n url: z.string().url()\n});\n/** @deprecated don't use */\nexport type RemoteRegistryV1Spec = z.infer<typeof RemoteRegistryV1Spec>;\n\nexport const RemoteRegistryV2Spec = z.object({\n type: z.literal('remote-v2'),\n url: z.string().url()\n});\nexport type RemoteRegistryV2Spec = z.infer<typeof RemoteRegistryV2Spec>;\n\nexport const RegistrySpec = z.discriminatedUnion('type', [\n RemoteRegistryV1Spec,\n RemoteRegistryV2Spec,\n LocalDevFolder\n]);\nexport type RegistrySpec = z.infer<typeof RegistrySpec>;\n\nexport const RegistryEntry = z.object({\n id: z.string(),\n title: z.string().optional(),\n spec: RegistrySpec\n});\nexport type RegistryEntry = z.infer<typeof RegistryEntry>;\n\nexport const RegistryList = z.array(RegistryEntry);\nexport type RegistryList = z.infer<typeof RegistryList>;\n","import { z } from 'zod';\nimport {\n BlockPackId,\n BlockPackIdNoVersion,\n BlockPackMetaEmbeddedBytes,\n SemVer\n} from '../block_meta';\nimport { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';\nimport { RegistryEntry } from './registry_spec';\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverviewLegacy = z.object({\n registryId: z.string(),\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec,\n otherVersions: z.array(SemVer)\n});\nexport type BlockPackOverviewLegacy = z.infer<typeof BlockPackOverviewLegacy>;\n\nexport const AnyChannel = 'any';\nexport const StableChannel = 'stable';\n\nexport const VersionWithChannels = z.object({\n version: SemVer,\n channels: z.array(z.string())\n});\n\n/**\n * Information about specific block pack version.\n * */\nexport const SingleBlockPackOverview = z.object({\n id: BlockPackId,\n meta: BlockPackMetaEmbeddedBytes,\n spec: BlockPackSpec\n});\nexport type SingleBlockPackOverview = z.infer<typeof SingleBlockPackOverview>;\n\n/**\n * Latest information about specific block pack. Contain information about latest version of the package.\n * */\nexport const BlockPackOverview = z.object({\n id: BlockPackIdNoVersion,\n latestByChannel: z.record(z.string(), SingleBlockPackOverview),\n allVersions: z.array(VersionWithChannels),\n registryId: z.string()\n});\nexport type BlockPackOverview = z.infer<typeof BlockPackOverview>;\n\nexport const RegistryStatus = RegistryEntry.extend({\n status: z.union([z.literal('online'), z.literal('offline')])\n});\nexport type RegistryStatus = z.infer<typeof RegistryStatus>;\n\nexport const BlockPackListing = z.object({\n registries: z.array(RegistryStatus),\n blockPacks: z.array(BlockPackOverview)\n});\nexport type BlockPackListing = z.infer<typeof BlockPackListing>;\n\nexport function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOverviewLegacy {\n const mainChannel = bpo.latestByChannel[StableChannel] !== undefined ? StableChannel : AnyChannel;\n const latestOverview = bpo.latestByChannel[mainChannel];\n return {\n id: latestOverview.id,\n meta: latestOverview.meta,\n // so we only add stable channel specs to projects, to smooth the transition\n spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },\n otherVersions: bpo.allVersions\n .filter((v) => v.channels.indexOf(mainChannel) >= 0)\n .map((v) => v.version),\n registryId: bpo.registryId\n };\n}\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","absPathRegex","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicitBytes","ContentAbsoluteFolder","ContentAny","ContentExplicitOrRelative","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","SemVer","mapRemoteToAbsolute","rootUrl","rootWithSlash","addPrefixToRelative","prefix","prefixWithSlash","BlockPackId","BlockPackIdNoVersion","blockPackIdToString","bp","blockPackIdNoVersionToString","blockPackIdEquals","bp1","bp2","blockPackIdNoVersionEquals","WorkflowV1","contentType","Workflow","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedBase64","BlockPackMetaEmbeddedBytes","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","overrideDescriptionVersion","manifest","newVersion","R","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","Sha256Schema","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile","overrideManifestVersion","BlockPackDevV1","BlockPackDevV2","BlockPackFromRegistryV1","BlockPackFromRegistryV2","BlockPackSpec","LocalDevFolder","RemoteRegistryV1Spec","RemoteRegistryV2Spec","RegistrySpec","RegistryEntry","RegistryList","BlockPackOverviewLegacy","AnyChannel","StableChannel","VersionWithChannels","SingleBlockPackOverview","BlockPackOverview","RegistryStatus","BlockPackListing","blockPackOverviewToLegacy","bpo","mainChannel","latestOverview","v"],"mappings":"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"}
package/dist/pframe/internal_api/api_read.d.ts CHANGED
@@ -2,29 +2,7 @@ import { FindColumnsRequest, FindColumnsResponse } from './find_columns';
2
2
  import { DeleteColumnFromColumnsRequest, DeleteColumnFromColumnsResponse } from './delete_column';
3
3
  import { PColumnInfo, PColumnSpec, PObjectId, UniqueValuesRequest, UniqueValuesResponse } from '@milaboratories/pl-model-common';
4
4
  import { CreateTableRequest } from './create_table';
5
- import { PTable, PTableV2 } from './table';
6
- /** Read interface exposed by PFrames library */
7
- export interface PFrameReadAPI {
8
- /**
9
- * Finds columns given filtering criteria on column name, annotations etc.
10
- * and a set of qualified axes specs to find only columns with compatible
11
- * axes spec.
12
- *
13
- * Only column specs are used, this method will work even for columns
14
- * with no assigned data.
15
- * */
16
- findColumns(request: FindColumnsRequest): Promise<FindColumnsResponse>;
17
- /** To be reviewed in the future */
18
- deleteColumn(request: DeleteColumnFromColumnsRequest): Promise<DeleteColumnFromColumnsResponse>;
19
- /** Retrieve single column spec */
20
- getColumnSpec(columnId: PObjectId): Promise<PColumnSpec>;
21
- /** Retrieve information about all columns currently added to the PFrame */
22
- listColumns(): Promise<PColumnInfo[]>;
23
- /** Calculates data for the table and returns an object to access it */
24
- createTable(request: CreateTableRequest): Promise<PTable>;
25
- /** Calculate set of unique values for a specific axis for the filtered set of records */
26
- getUniqueValues(request: UniqueValuesRequest): Promise<UniqueValuesResponse>;
27
- }
5
+ import { PTableV2 } from './table';
28
6
  /** Read interface exposed by PFrames library */
29
7
  export interface PFrameReadAPIV2 {
30
8
  /**
package/dist/pframe/internal_api/api_read.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"api_read.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/api_read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,8BAA8B,EAAE,+BAA+B,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE3C,gDAAgD;AAChD,MAAM,WAAW,aAAa;IAC5B;;;;;;;SAOK;IACL,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEvE,mCAAmC;IACnC,YAAY,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAEhG,kCAAkC;IAClC,aAAa,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEzD,2EAA2E;IAC3E,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEtC,uEAAuE;IACvE,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE1D,yFAAyF;IACzF,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC9E;AAED,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B;;;;;;;SAOK;IACL,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEvE,mCAAmC;IACnC,YAAY,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAEhG,kCAAkC;IAClC,aAAa,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEzD,2EAA2E;IAC3E,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEtC,uEAAuE;IACvE,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE5D,yFAAyF;IACzF,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC9E"}
1
+ {"version":3,"file":"api_read.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/api_read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,8BAA8B,EAAE,+BAA+B,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B;;;;;;;SAOK;IACL,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEvE,mCAAmC;IACnC,YAAY,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAEhG,kCAAkC;IAClC,aAAa,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEzD,2EAA2E;IAC3E,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEtC,uEAAuE;IACvE,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE5D,yFAAyF;IACzF,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC9E"}
package/dist/pframe/internal_api/pframe.d.ts CHANGED
@@ -1,6 +1,4 @@
1
- import { PFrameReadAPI, PFrameFactoryAPI, PFrameReadAPIV2 } from './index';
2
- export interface PFrame extends PFrameFactoryAPI, PFrameReadAPI {
3
- }
1
+ import { PFrameFactoryAPI, PFrameReadAPIV2 } from './index';
4
2
  export interface PFrameV2 extends PFrameFactoryAPI, PFrameReadAPIV2 {
5
3
  }
6
4
  //# sourceMappingURL=pframe.d.ts.map
package/dist/pframe/internal_api/pframe.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"pframe.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/pframe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE3E,MAAM,WAAW,MAAO,SAAQ,gBAAgB,EAAE,aAAa;CAC9D;AAED,MAAM,WAAW,QAAS,SAAQ,gBAAgB,EAAE,eAAe;CAClE"}
1
+ {"version":3,"file":"pframe.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/pframe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE5D,MAAM,WAAW,QAAS,SAAQ,gBAAgB,EAAE,eAAe;CAClE"}
package/dist/pframe/internal_api/table.d.ts CHANGED
@@ -1,39 +1,4 @@
1
1
  import { PTableColumnId, PTableColumnSpec, PTableRecordFilter, PTableShape, PTableSorting, PTableVector, TableRange } from '@milaboratories/pl-model-common';
2
- /**
3
- * Table view returned as a result of create table operation.
4
- *
5
- * PTable can be thought as having a composite primary key, consisting of axes,
6
- * and a set of data columns derived from PColumn values.
7
- * */
8
- export interface PTable {
9
- /** Unified table shape */
10
- getShape(): PTableShape;
11
- /**
12
- * Returns ordered array of table axes specs (primary key "columns" in SQL
13
- * terms) and data column specs (regular "columns" in SQL terms).
14
- *
15
- * Data for a specific table column can be retrieved using unified indexing
16
- * corresponding to elements in this array.
17
- *
18
- * Axes are always listed first.
19
- * */
20
- getSpec(): PTableColumnSpec[];
21
- /** Transforms unified column identifiers into unified indices of columns. */
22
- getColumnIndices(columnIds: PTableColumnId[]): number[];
23
- /**
24
- * Retrieve the data from the table. To retrieve only data required, it can be
25
- * sliced both horizontally ({@link columnIndices}) and vertically
26
- * ({@link range}).
27
- *
28
- * @param columnIndices unified indices of columns to be retrieved
29
- * @param range optionally limit the range of records to retrieve
30
- * */
31
- getData(columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
32
- /** Sorts the table and returns new PTable instance. */
33
- sort(request: PTableSorting[]): Promise<PTable>;
34
- /** Deallocates all underlying resources */
35
- dispose(): void;
36
- }
37
2
  /**
38
3
  * Table view returned as a result of create table operation.
39
4
  *
package/dist/pframe/internal_api/table.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/table.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC;;;;;KAKK;AACL,MAAM,WAAW,MAAM;IACrB,0BAA0B;IAC1B,QAAQ,IAAI,WAAW,CAAC;IAExB;;;;;;;;SAQK;IACL,OAAO,IAAI,gBAAgB,EAAE,CAAC;IAE9B,6EAA6E;IAC7E,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC;IAExD;;;;;;;SAOK;IACL,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAE9E,uDAAuD;IACvD,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEhD,2CAA2C;IAC3C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;KAKK;AACL,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,QAAQ,IAAI,WAAW,CAAC;IAExB;;;;;;;;SAQK;IACL,OAAO,IAAI,gBAAgB,EAAE,CAAC;IAE9B,6EAA6E;IAC7E,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC;IAExD;;;;;;;SAOK;IACL,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAE9E,wDAAwD;IACxD,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEzD,uDAAuD;IACvD,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAElD,2CAA2C;IAC3C,OAAO,IAAI,IAAI,CAAC;CACjB"}
1
+ {"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/pframe/internal_api/table.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC;;;;;KAKK;AACL,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,QAAQ,IAAI,WAAW,CAAC;IAExB;;;;;;;;SAQK;IACL,OAAO,IAAI,gBAAgB,EAAE,CAAC;IAE9B,6EAA6E;IAC7E,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC;IAExD;;;;;;;SAOK;IACL,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAE9E,wDAAwD;IACxD,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEzD,uDAAuD;IACvD,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAElD,2CAA2C;IAC3C,OAAO,IAAI,IAAI,CAAC;CACjB"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@milaboratories/pl-model-middle-layer",
3
- "version": "1.6.2",
3
+ "version": "1.6.4",
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",
package/src/block_registry/overview.ts CHANGED
@@ -5,7 +5,7 @@ import {
5
5
  BlockPackMetaEmbeddedBytes,
6
6
  SemVer
7
7
  } from '../block_meta';
8
- import { BlockPackSpec } from './block_pack_spec';
8
+ import { BlockPackFromRegistryV2, BlockPackSpec } from './block_pack_spec';
9
9
  import { RegistryEntry } from './registry_spec';
10
10
 
11
11
  /**
@@ -66,7 +66,8 @@ export function blockPackOverviewToLegacy(bpo: BlockPackOverview): BlockPackOver
66
66
  return {
67
67
  id: latestOverview.id,
68
68
  meta: latestOverview.meta,
69
- spec: latestOverview.spec,
69
+ // so we only add stable channel specs to projects, to smooth the transition
70
+ spec: { ...(latestOverview.spec as BlockPackFromRegistryV2), channel: StableChannel },
70
71
  otherVersions: bpo.allVersions
71
72
  .filter((v) => v.channels.indexOf(mainChannel) >= 0)
72
73
  .map((v) => v.version),
package/src/pframe/internal_api/api_read.ts CHANGED
@@ -8,35 +8,7 @@ import {
8
8
  UniqueValuesResponse
9
9
  } from '@milaboratories/pl-model-common';
10
10
  import { CreateTableRequest } from './create_table';
11
- import { PTable, PTableV2 } from './table';
12
-
13
- /** Read interface exposed by PFrames library */
14
- export interface PFrameReadAPI {
15
- /**
16
- * Finds columns given filtering criteria on column name, annotations etc.
17
- * and a set of qualified axes specs to find only columns with compatible
18
- * axes spec.
19
- *
20
- * Only column specs are used, this method will work even for columns
21
- * with no assigned data.
22
- * */
23
- findColumns(request: FindColumnsRequest): Promise<FindColumnsResponse>;
24
-
25
- /** To be reviewed in the future */
26
- deleteColumn(request: DeleteColumnFromColumnsRequest): Promise<DeleteColumnFromColumnsResponse>;
27
-
28
- /** Retrieve single column spec */
29
- getColumnSpec(columnId: PObjectId): Promise<PColumnSpec>;
30
-
31
- /** Retrieve information about all columns currently added to the PFrame */
32
- listColumns(): Promise<PColumnInfo[]>;
33
-
34
- /** Calculates data for the table and returns an object to access it */
35
- createTable(request: CreateTableRequest): Promise<PTable>;
36
-
37
- /** Calculate set of unique values for a specific axis for the filtered set of records */
38
- getUniqueValues(request: UniqueValuesRequest): Promise<UniqueValuesResponse>;
39
- }
11
+ import { PTableV2 } from './table';
40
12
 
41
13
  /** Read interface exposed by PFrames library */
42
14
  export interface PFrameReadAPIV2 {
package/src/pframe/internal_api/pframe.ts CHANGED
@@ -1,7 +1,4 @@
1
- import { PFrameReadAPI, PFrameFactoryAPI, PFrameReadAPIV2 } from './index';
2
-
3
- export interface PFrame extends PFrameFactoryAPI, PFrameReadAPI {
4
- }
1
+ import { PFrameFactoryAPI, PFrameReadAPIV2 } from './index';
5
2
 
6
3
  export interface PFrameV2 extends PFrameFactoryAPI, PFrameReadAPIV2 {
7
4
  }
package/src/pframe/internal_api/table.ts CHANGED
@@ -8,47 +8,6 @@ import {
8
8
  TableRange
9
9
  } from '@milaboratories/pl-model-common';
10
10
 
11
- /**
12
- * Table view returned as a result of create table operation.
13
- *
14
- * PTable can be thought as having a composite primary key, consisting of axes,
15
- * and a set of data columns derived from PColumn values.
16
- * */
17
- export interface PTable {
18
- /** Unified table shape */
19
- getShape(): PTableShape;
20
-
21
- /**
22
- * Returns ordered array of table axes specs (primary key "columns" in SQL
23
- * terms) and data column specs (regular "columns" in SQL terms).
24
- *
25
- * Data for a specific table column can be retrieved using unified indexing
26
- * corresponding to elements in this array.
27
- *
28
- * Axes are always listed first.
29
- * */
30
- getSpec(): PTableColumnSpec[];
31
-
32
- /** Transforms unified column identifiers into unified indices of columns. */
33
- getColumnIndices(columnIds: PTableColumnId[]): number[];
34
-
35
- /**
36
- * Retrieve the data from the table. To retrieve only data required, it can be
37
- * sliced both horizontally ({@link columnIndices}) and vertically
38
- * ({@link range}).
39
- *
40
- * @param columnIndices unified indices of columns to be retrieved
41
- * @param range optionally limit the range of records to retrieve
42
- * */
43
- getData(columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
44
-
45
- /** Sorts the table and returns new PTable instance. */
46
- sort(request: PTableSorting[]): Promise<PTable>;
47
-
48
- /** Deallocates all underlying resources */
49
- dispose(): void;
50
- }
51
-
52
11
  /**
53
12
  * Table view returned as a result of create table operation.
54
13
  *