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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/block_meta/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/block_meta/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AAEzB,cAAc,sBAAsB,CAAC;AAErC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),s=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),o=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(),c=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().startsWith("/").describe("Absolute address of the file in local file system")}).strict(),r=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),M=t.z.object({type:t.z.literal("explicit"),content:t.z.instanceof(Uint8Array).describe("Raw content")}).strict(),w=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().startsWith("/").describe("Absolute address of the folder in local file system")}).strict(),j=t.z.discriminatedUnion("type",[s,i,o,c,r]),v=t.z.discriminatedUnion("type",[s,i,o,c]),D=t.z.discriminatedUnion("type",[s,i,o,r]),y=t.z.discriminatedUnion("type",[i,o,c]),C=t.z.discriminatedUnion("type",[s,o,c]),U=t.z.discriminatedUnion("type",[i,r]),T=t.z.discriminatedUnion("type",[i,c]),L=t.z.discriminatedUnion("type",[s,r]),S=t.z.discriminatedUnion("type",[s,c]),a=t.z.discriminatedUnion("type",[i,o]),f=t.z.discriminatedUnion("type",[s,o]),g=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),y]),B=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),C]);function b(e){const n=e.endsWith("/")?e:`${e}/`;return z=>z.type==="relative"?{type:"absolute-url",url:n+z.path}:z}function F(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})),t.z.discriminatedUnion("type",[t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})])])}function l(e,n){return t.z.object({workflow:e,model:e,ui:n})}const d=l(t.z.string(),t.z.string()),A=l(o,o);function E(e){return l(a.transform(b(e)),a.transform(b(e)))}const 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"),u=t.z.object({organization:t.z.string(),name:t.z.string(),version:P}).strict(),W=u.omit({version:!0});function p(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription: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()})})}const m=p(B,g),h=p(f,a),I=p(t.z.string(),i),Z=t.z.object({components:d,meta:m});function k(e,n){return t.z.object({id:u,components:e,meta:n})}const x=k(A,h),V=k(d,m),R=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64)}),_=t.z.object({schema:t.z.literal("v1"),description:x,files:t.z.array(R)}),O=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=l;exports.BlockComponentsAbsoluteUrl=E;exports.BlockComponentsDescriptionRaw=d;exports.BlockComponentsManifest=A;exports.BlockPackDescriptionFromPackageJsonRaw=Z;exports.BlockPackDescriptionManifest=x;exports.BlockPackDescriptionRaw=V;exports.BlockPackId=u;exports.BlockPackIdNoVersion=W;exports.BlockPackManifest=_;exports.BlockPackMeta=p;exports.BlockPackMetaDescriptionRaw=m;exports.BlockPackMetaEmbeddedContent=I;exports.BlockPackMetaManifest=h;exports.ContentAbsoluteBinaryLocal=T;exports.ContentAbsoluteBinaryRemote=U;exports.ContentAbsoluteFile=c;exports.ContentAbsoluteFolder=w;exports.ContentAbsoluteTextLocal=S;exports.ContentAbsoluteTextRemote=L;exports.ContentAbsoluteUrl=r;exports.ContentAny=j;exports.ContentAnyBinaryLocal=y;exports.ContentAnyLocal=v;exports.ContentAnyRemote=D;exports.ContentAnyTextLocal=C;exports.ContentExplicit=M;exports.ContentExplicitBase64=i;exports.ContentExplicitString=s;exports.ContentRelative=o;exports.ContentRelativeBinary=a;exports.ContentRelativeText=f;exports.CreateBlockPackDescriptionSchema=k;exports.DescriptionContentBinary=g;exports.DescriptionContentText=B;exports.ManifestFileInfo=R;exports.PFrameInternal=O;exports.SemVer=P;exports.Workflow=F;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),s=t.z.object({type:t.z.literal("explicit-string"),content:t.z.string().describe("Actual string value")}).strict(),i=t.z.object({type:t.z.literal("explicit-base64"),mimeType:t.z.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),content:t.z.string().base64().describe("Base64 encoded binary value")}).strict(),o=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=t.z.object({type:t.z.literal("absolute-file"),file:t.z.string().startsWith("/").describe("Absolute address of the file in local file system")}).strict(),a=t.z.object({type:t.z.literal("absolute-url"),url:t.z.string().url().describe("Global URL to reach the requested file")}).strict(),v=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(),w=t.z.object({type:t.z.literal("absolute-folder"),folder:t.z.string().startsWith("/").describe("Absolute address of the folder in local file system")}).strict(),j=t.z.discriminatedUnion("type",[s,i,o,r,a]),U=t.z.discriminatedUnion("type",[s,i,o]),D=t.z.discriminatedUnion("type",[s,i,o,r]),T=t.z.discriminatedUnion("type",[s,i,o,a]),b=t.z.discriminatedUnion("type",[i,o,r]),f=t.z.discriminatedUnion("type",[s,o,r]),E=t.z.discriminatedUnion("type",[i,a]),F=t.z.discriminatedUnion("type",[i,r]),S=t.z.discriminatedUnion("type",[s,a]),L=t.z.discriminatedUnion("type",[s,r]),l=t.z.discriminatedUnion("type",[i,o]),C=t.z.discriminatedUnion("type",[s,o]),g=t.z.union([t.z.string().startsWith("file:").transform((e,n)=>({type:"relative",path:e.slice(5)})),b]),B=t.z.union([t.z.string().transform((e,n)=>e.startsWith("file:")?{type:"relative",path:e.slice(5)}:{type:"explicit-string",content:e}),f]),A=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 d(e){const n=e.endsWith("/")?e:`${e}/`;return c=>c.type==="relative"?{type:"absolute-url",url:n+c.path}:c}function W(e){const n=e.endsWith("/")?e:`${e}/`;return c=>c.type==="relative"?{type:"relative",path:n+c.path}:c}const m=t.z.object({organization:t.z.string(),name:t.z.string(),version:A}).strict(),I=m.omit({version:!0});function P(e){return t.z.union([e.transform(n=>({type:"workflow-v1",main:n})),t.z.discriminatedUnion("type",[t.z.object({type:t.z.literal("workflow-v1"),main:e.describe("Main workflow")})])])}function p(e,n){return t.z.object({workflow:P(e),model:e,ui:n})}const u=p(t.z.string(),t.z.string());function Z(e){return p(l.transform(d(e)),l.transform(d(e)))}function z(e,n){return t.z.object({title:t.z.string(),description:t.z.string(),longDescription: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()})})}const k=z(B,g),O=z(t.z.string(),i),V=t.z.object({components:u,meta:k});function y(e,n){return t.z.object({id:m,components:e,meta:n})}const _=y(u,k),h=p(o,o),x=z(C,l),R=y(h,x),M=t.z.object({name:t.z.string(),size:t.z.number().int(),sha256:t.z.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64)}),$=t.z.object({schema:t.z.literal("v2"),description:R,files:t.z.array(M)}),q="manifest.json",J=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));exports.BlockComponents=p;exports.BlockComponentsAbsoluteUrl=Z;exports.BlockComponentsDescriptionRaw=u;exports.BlockComponentsManifest=h;exports.BlockPackDescriptionFromPackageJsonRaw=V;exports.BlockPackDescriptionManifest=R;exports.BlockPackDescriptionRaw=_;exports.BlockPackId=m;exports.BlockPackIdNoVersion=I;exports.BlockPackManifest=$;exports.BlockPackManifestFile=q;exports.BlockPackMeta=z;exports.BlockPackMetaDescriptionRaw=k;exports.BlockPackMetaEmbeddedContent=O;exports.BlockPackMetaManifest=x;exports.ContentAbsoluteBinaryLocal=F;exports.ContentAbsoluteBinaryRemote=E;exports.ContentAbsoluteFile=r;exports.ContentAbsoluteFolder=w;exports.ContentAbsoluteTextLocal=L;exports.ContentAbsoluteTextRemote=S;exports.ContentAbsoluteUrl=a;exports.ContentAny=j;exports.ContentAnyBinaryLocal=b;exports.ContentAnyLocal=D;exports.ContentAnyRemote=T;exports.ContentAnyTextLocal=f;exports.ContentExplicitBase64=i;exports.ContentExplicitBytes=v;exports.ContentExplicitOrRelative=U;exports.ContentExplicitString=s;exports.ContentRelative=o;exports.ContentRelativeBinary=l;exports.ContentRelativeText=C;exports.CreateBlockPackDescriptionSchema=y;exports.DescriptionContentBinary=g;exports.DescriptionContentText=B;exports.ManifestFileInfo=M;exports.PFrameInternal=J;exports.SemVer=A;exports.Workflow=P;exports.addPrefixToRelative=W;exports.mapRemoteToAbsolute=d;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/block_meta/content_types.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_components.ts","../src/block_meta/semver.ts","../src/block_meta/block_pack_id.ts","../src/block_meta/meta.ts","../src/block_meta/index.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\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').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 ContentExplicit = z\n  .object({\n    type: z.literal('explicit'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicit = z.infer<typeof ContentExplicit>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\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 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 { ContentAbsoluteUrl, ContentAnyLocal, ContentRelative } from \"./content_types\";\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(\n  value: T\n) => 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","import { z } from 'zod';\nimport { ContentRelative, ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType.transform((value) => ({\n      type: 'workflow-v1',\n      main: value\n    })),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [\n      z.object({\n        type: z.literal('workflow-v1'),\n        main: contentType.describe('Main workflow')\n      })\n    ])\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: 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 const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\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","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 { 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","import { z } from 'zod';\nimport {\n  ContentAbsoluteBinaryLocal,\n  ContentAbsoluteTextLocal,\n  ContentExplicitBase64,\n  ContentExplicitString,\n  ContentRelative,\n  ContentRelativeBinary,\n  ContentRelativeText,\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    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaManifest = BlockPackMeta(\n  ContentRelativeText,\n  ContentRelativeBinary\n);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedContent = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedContent = z.infer<typeof BlockPackMetaEmbeddedContent>;\n","import { ZodTypeAny, string, z } from 'zod';\nimport { BlockComponentsDescriptionRaw, BlockComponentsManifest } from './block_components';\nimport { BlockPackId } from './block_pack_id';\nimport { BlockPackMetaDescriptionRaw, BlockPackMetaManifest } from './meta';\n\nexport * from './block_components';\nexport * from './block_pack_id';\nexport * from './common';\nexport * from './content_types';\nexport * from './meta';\nexport * from './semver';\n\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 BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: z\n    .string()\n    .regex(/[0-9a-fA-F]/)\n    .toUpperCase()\n    .length(64) // 256 / 4 (bits per hex register)\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v1'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicit","ContentAbsoluteFolder","ContentAny","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","mapRemoteToAbsolute","rootUrl","rootWithSlash","Workflow","contentType","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsManifest","BlockComponentsAbsoluteUrl","prefix","SemVer","BlockPackId","BlockPackIdNoVersion","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaManifest","BlockPackMetaEmbeddedContent","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionManifest","BlockPackDescriptionRaw","ManifestFileInfo","BlockPackManifest"],"mappings":"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"}
+{"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"],"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\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').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      .startsWith('/')\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","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType.transform((value) => ({\n      type: 'workflow-v1',\n      main: value\n    })),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [\n      z.object({\n        type: z.literal('workflow-v1'),\n        main: contentType.describe('Main workflow')\n      })\n    ])\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\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    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedContent = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedContent = z.infer<typeof BlockPackMetaEmbeddedContent>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: z\n    .string()\n    .regex(/[0-9a-fA-F]/)\n    .toUpperCase()\n    .length(64) // 256 / 4 (bits per hex register)\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","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","Workflow","contentType","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedContent","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile"],"mappings":"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"}

package/dist/index.mjs

@@ -2,81 +2,98 @@ import { z as t } from "zod";
 const s = t.object({
   type: t.literal("explicit-string"),
   content: t.string().describe("Actual string value")
-}).strict(), i = t.object({
+}).strict(), o = t.object({
   type: t.literal("explicit-base64"),
   mimeType: t.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),
   content: t.string().base64().describe("Base64 encoded binary value")
-}).strict(), o = t.object({
+}).strict(), i = t.object({
   type: t.literal("relative"),
   path: t.string().describe(
     "Address of the file, in most cases relative to the file which this structure is a part of"
   )
-}).strict(), r = t.object({
+}).strict(), c = t.object({
   type: t.literal("absolute-file"),
   file: t.string().startsWith("/").describe("Absolute address of the file in local file system")
-}).strict(), c = t.object({
+}).strict(), a = t.object({
   type: t.literal("absolute-url"),
   url: t.string().url().describe("Global URL to reach the requested file")
-}).strict(), P = t.object({
-  type: t.literal("explicit"),
+}).strict(), M = t.object({
+  type: t.literal("explicit-bytes"),
+  mimeType: t.string().regex(/\w+\/[-+.\w]+/).describe("MIME type to interpret content"),
   content: t.instanceof(Uint8Array).describe("Raw content")
 }).strict(), R = t.object({
   type: t.literal("absolute-folder"),
   folder: t.string().startsWith("/").describe("Absolute address of the folder in local file system")
-}).strict(), M = t.discriminatedUnion("type", [
+}).strict(), z = t.discriminatedUnion("type", [
   s,
-  i,
   o,
-  r,
-  c
-]), z = t.discriminatedUnion("type", [
-  s,
   i,
+  c,
+  a
+]), W = t.discriminatedUnion("type", [
+  s,
   o,
-  r
+  i
 ]), D = t.discriminatedUnion("type", [
   s,
-  i,
   o,
+  i,
   c
-]), y = t.discriminatedUnion("type", [
+]), T = t.discriminatedUnion("type", [
+  s,
+  o,
   i,
+  a
+]), g = t.discriminatedUnion("type", [
   o,
-  r
+  i,
+  c
 ]), k = t.discriminatedUnion("type", [
   s,
-  o,
-  r
-]), W = t.discriminatedUnion("type", [
   i,
   c
-]), T = t.discriminatedUnion("type", [
-  i,
-  r
+]), E = t.discriminatedUnion("type", [
+  o,
+  a
 ]), F = t.discriminatedUnion("type", [
-  s,
+  o,
   c
-]), L = t.discriminatedUnion("type", [
+]), S = t.discriminatedUnion("type", [
+  s,
+  a
+]), I = t.discriminatedUnion("type", [
   s,
-  r
+  c
 ]), l = t.discriminatedUnion("type", [
-  i,
-  o
-]), C = t.discriminatedUnion("type", [
+  o,
+  i
+]), h = t.discriminatedUnion("type", [
   s,
-  o
-]), A = t.union([
+  i
+]), C = t.union([
   t.string().startsWith("file:").transform((e, n) => ({ type: "relative", path: e.slice(5) })),
-  y
-]), h = t.union([
+  g
+]), A = t.union([
   t.string().transform((e, n) => e.startsWith("file:") ? { type: "relative", path: e.slice(5) } : { type: "explicit-string", content: e }),
   k
-]);
+]), B = t.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 m(e) {
   const n = e.endsWith("/") ? e : `${e}/`;
-  return (a) => a.type === "relative" ? { type: "absolute-url", url: n + a.path } : a;
+  return (r) => r.type === "relative" ? { type: "absolute-url", url: n + r.path } : r;
+}
+function L(e) {
+  const n = e.endsWith("/") ? e : `${e}/`;
+  return (r) => r.type === "relative" ? { type: "relative", path: n + r.path } : r;
 }
-function S(e) {
+const u = t.object({
+  organization: t.string(),
+  name: t.string(),
+  version: B
+}).strict(), Z = u.omit({ version: !0 });
+function x(e) {
   return t.union([
     // string is converted to v1 workflow
     e.transform((n) => ({
@@ -94,26 +111,18 @@ function S(e) {
 }
 function p(e, n) {
   return t.object({
-    workflow: e,
+    workflow: x(e),
     model: e,
     ui: n
   });
 }
-const u = p(t.string(), t.string()), B = p(o, o);
-function Z(e) {
+const y = p(t.string(), t.string());
+function _(e) {
   return p(
     l.transform(m(e)),
     l.transform(m(e))
   );
 }
-const j = t.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"
-), b = t.object({
-  organization: t.string(),
-  name: t.string(),
-  version: j
-}).strict(), E = b.omit({ version: !0 });
 function d(e, n) {
   return t.object({
     title: t.string(),
@@ -131,83 +140,84 @@ function d(e, n) {
     })
   });
 }
-const f = d(
-  h,
-  A
-), x = d(
-  C,
-  l
-), I = d(
+const b = d(
+  A,
+  C
+), O = d(
   t.string(),
-  i
-), _ = t.object({
-  components: u,
-  meta: f
+  o
+), $ = t.object({
+  components: y,
+  meta: b
 });
-function g(e, n) {
+function f(e, n) {
   return t.object({
-    id: b,
+    id: u,
     components: e,
     meta: n
   });
 }
-const w = g(
-  B,
-  x
-), O = g(
-  u,
-  f
-), v = t.object({
+const V = f(
+  y,
+  b
+), j = p(i, i), w = d(h, l), v = f(
+  j,
+  w
+), P = t.object({
   name: t.string(),
   size: t.number().int(),
   sha256: t.string().regex(/[0-9a-fA-F]/).toUpperCase().length(64)
   // 256 / 4 (bits per hex register)
-}), V = t.object({
-  schema: t.literal("v1"),
-  description: w,
-  files: t.array(v)
-}), $ = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), q = t.object({
+  schema: t.literal("v2"),
+  description: v,
+  files: t.array(P)
+}), G = "manifest.json", J = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
 }, Symbol.toStringTag, { value: "Module" }));
 export {
   p as BlockComponents,
-  Z as BlockComponentsAbsoluteUrl,
-  u as BlockComponentsDescriptionRaw,
-  B as BlockComponentsManifest,
-  _ as BlockPackDescriptionFromPackageJsonRaw,
-  w as BlockPackDescriptionManifest,
-  O as BlockPackDescriptionRaw,
-  b as BlockPackId,
-  E as BlockPackIdNoVersion,
-  V as BlockPackManifest,
+  _ as BlockComponentsAbsoluteUrl,
+  y as BlockComponentsDescriptionRaw,
+  j as BlockComponentsManifest,
+  $ as BlockPackDescriptionFromPackageJsonRaw,
+  v as BlockPackDescriptionManifest,
+  V as BlockPackDescriptionRaw,
+  u as BlockPackId,
+  Z as BlockPackIdNoVersion,
+  q as BlockPackManifest,
+  G as BlockPackManifestFile,
   d as BlockPackMeta,
-  f as BlockPackMetaDescriptionRaw,
-  I as BlockPackMetaEmbeddedContent,
-  x as BlockPackMetaManifest,
-  T as ContentAbsoluteBinaryLocal,
-  W as ContentAbsoluteBinaryRemote,
-  r as ContentAbsoluteFile,
+  b as BlockPackMetaDescriptionRaw,
+  O as BlockPackMetaEmbeddedContent,
+  w as BlockPackMetaManifest,
+  F as ContentAbsoluteBinaryLocal,
+  E as ContentAbsoluteBinaryRemote,
+  c as ContentAbsoluteFile,
   R as ContentAbsoluteFolder,
-  L as ContentAbsoluteTextLocal,
-  F as ContentAbsoluteTextRemote,
-  c as ContentAbsoluteUrl,
-  M as ContentAny,
-  y as ContentAnyBinaryLocal,
-  z as ContentAnyLocal,
-  D as ContentAnyRemote,
+  I as ContentAbsoluteTextLocal,
+  S as ContentAbsoluteTextRemote,
+  a as ContentAbsoluteUrl,
+  z as ContentAny,
+  g as ContentAnyBinaryLocal,
+  D as ContentAnyLocal,
+  T as ContentAnyRemote,
   k as ContentAnyTextLocal,
-  P as ContentExplicit,
-  i as ContentExplicitBase64,
+  o as ContentExplicitBase64,
+  M as ContentExplicitBytes,
+  W as ContentExplicitOrRelative,
   s as ContentExplicitString,
-  o as ContentRelative,
+  i as ContentRelative,
   l as ContentRelativeBinary,
-  C as ContentRelativeText,
-  g as CreateBlockPackDescriptionSchema,
-  A as DescriptionContentBinary,
-  h as DescriptionContentText,
-  v as ManifestFileInfo,
-  $ as PFrameInternal,
-  j as SemVer,
-  S as Workflow
+  h as ContentRelativeText,
+  f as CreateBlockPackDescriptionSchema,
+  C as DescriptionContentBinary,
+  A as DescriptionContentText,
+  P as ManifestFileInfo,
+  J as PFrameInternal,
+  B as SemVer,
+  x as Workflow,
+  L as addPrefixToRelative,
+  m as mapRemoteToAbsolute
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/block_meta/content_types.ts","../src/block_meta/content_conversion.ts","../src/block_meta/block_components.ts","../src/block_meta/semver.ts","../src/block_meta/block_pack_id.ts","../src/block_meta/meta.ts","../src/block_meta/index.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\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').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 ContentExplicit = z\n  .object({\n    type: z.literal('explicit'),\n    content: z.instanceof(Uint8Array).describe('Raw content')\n  })\n  .strict();\nexport type ContentExplicit = z.infer<typeof ContentExplicit>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal('absolute-folder'),\n    folder: z\n      .string()\n      .startsWith('/')\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 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 { ContentAbsoluteUrl, ContentAnyLocal, ContentRelative } from \"./content_types\";\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string\n): <T extends ContentAnyLocal>(\n  value: T\n) => 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","import { z } from 'zod';\nimport { ContentRelative, ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType.transform((value) => ({\n      type: 'workflow-v1',\n      main: value\n    })),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [\n      z.object({\n        type: z.literal('workflow-v1'),\n        main: contentType.describe('Main workflow')\n      })\n    ])\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: 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 const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\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","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 { 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","import { z } from 'zod';\nimport {\n  ContentAbsoluteBinaryLocal,\n  ContentAbsoluteTextLocal,\n  ContentExplicitBase64,\n  ContentExplicitString,\n  ContentRelative,\n  ContentRelativeBinary,\n  ContentRelativeText,\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    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaManifest = BlockPackMeta(\n  ContentRelativeText,\n  ContentRelativeBinary\n);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedContent = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedContent = z.infer<typeof BlockPackMetaEmbeddedContent>;\n","import { ZodTypeAny, string, z } from 'zod';\nimport { BlockComponentsDescriptionRaw, BlockComponentsManifest } from './block_components';\nimport { BlockPackId } from './block_pack_id';\nimport { BlockPackMetaDescriptionRaw, BlockPackMetaManifest } from './meta';\n\nexport * from './block_components';\nexport * from './block_pack_id';\nexport * from './common';\nexport * from './content_types';\nexport * from './meta';\nexport * from './semver';\n\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 BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: z\n    .string()\n    .regex(/[0-9a-fA-F]/)\n    .toUpperCase()\n    .length(64) // 256 / 4 (bits per hex register)\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v1'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","ContentAbsoluteFile","ContentAbsoluteUrl","ContentExplicit","ContentAbsoluteFolder","ContentAny","ContentAnyLocal","ContentAnyRemote","ContentAnyBinaryLocal","ContentAnyTextLocal","ContentAbsoluteBinaryRemote","ContentAbsoluteBinaryLocal","ContentAbsoluteTextRemote","ContentAbsoluteTextLocal","ContentRelativeBinary","ContentRelativeText","DescriptionContentBinary","value","ctx","DescriptionContentText","mapRemoteToAbsolute","rootUrl","rootWithSlash","Workflow","contentType","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsManifest","BlockComponentsAbsoluteUrl","prefix","SemVer","BlockPackId","BlockPackIdNoVersion","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaManifest","BlockPackMetaEmbeddedContent","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionManifest","BlockPackDescriptionRaw","ManifestFileInfo","BlockPackManifest"],"mappings":";AAMa,MAAAA,IAAwBC,EAClC,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,iBAAiB;AAAA,EACjC,SAASA,EAAE,SAAS,SAAS,qBAAqB;AACpD,CAAC,EACA,OAAO,GAGGC,IAAwBD,EAClC,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,iBAAiB;AAAA,EACjC,UAAUA,EACP,OAAO,EACP,MAAM,eAAe,EACrB,SAAS,gCAAgC;AAAA,EAC5C,SAASA,EAAE,OAAA,EAAS,OAAO,EAAE,SAAS,6BAA6B;AACrE,CAAC,EACA,OAAO,GAGGE,IAAkBF,EAC5B,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,UAAU;AAAA,EAC1B,MAAMA,EACH,OAAA,EACA;AAAA,IACC;AAAA,EACF;AACJ,CAAC,EACA,OAAO,GAGGG,IAAsBH,EAChC,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,eAAe;AAAA,EAC/B,MAAMA,EAAE,OAAO,EAAE,WAAW,GAAG,EAAE,SAAS,mDAAmD;AAC/F,CAAC,EACA,OAAO,GAGGI,IAAqBJ,EAC/B,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,cAAc;AAAA,EAC9B,KAAKA,EAAE,OAAA,EAAS,IAAI,EAAE,SAAS,wCAAwC;AACzE,CAAC,EACA,OAAO,GAOGK,IAAkBL,EAC5B,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,UAAU;AAAA,EAC1B,SAASA,EAAE,WAAW,UAAU,EAAE,SAAS,aAAa;AAC1D,CAAC,EACA,OAAO,GAGGM,IAAwBN,EAClC,OAAO;AAAA,EACN,MAAMA,EAAE,QAAQ,iBAAiB;AAAA,EACjC,QAAQA,EACL,OAAO,EACP,WAAW,GAAG,EACd,SAAS,qDAAqD;AACnE,CAAC,EACA,OAAO,GAOGO,IAAaP,EAAE,mBAAmB,QAAQ;AAAA,EACrDD;AAAA,EACAE;AAAA,EACAC;AAAA,EACAC;AAAA,EACAC;AACF,CAAC,GAGYI,IAAkBR,EAAE,mBAAmB,QAAQ;AAAA,EAC1DD;AAAA,EACAE;AAAA,EACAC;AAAA,EACAC;AACF,CAAC,GAGYM,IAAmBT,EAAE,mBAAmB,QAAQ;AAAA,EAC3DD;AAAA,EACAE;AAAA,EACAC;AAAA,EACAE;AACF,CAAC,GAcYM,IAAwBV,EAAE,mBAAmB,QAAQ;AAAA,EAChEC;AAAA,EACAC;AAAA,EACAC;AACF,CAAC,GAUYQ,IAAsBX,EAAE,mBAAmB,QAAQ;AAAA,EAC9DD;AAAA,EACAG;AAAA,EACAC;AACF,CAAC,GAOYS,IAA8BZ,EAAE,mBAAmB,QAAQ;AAAA,EACtEC;AAAA,EACAG;AACF,CAAC,GAGYS,IAA6Bb,EAAE,mBAAmB,QAAQ;AAAA,EACrEC;AAAA,EACAE;AACF,CAAC,GAGYW,IAA4Bd,EAAE,mBAAmB,QAAQ;AAAA,EACpED;AAAA,EACAK;AACF,CAAC,GAGYW,IAA2Bf,EAAE,mBAAmB,QAAQ;AAAA,EACnED;AAAA,EACAI;AACF,CAAC,GAOYa,IAAwBhB,EAAE,mBAAmB,QAAQ;AAAA,EAChEC;AAAA,EACAC;AACF,CAAC,GAGYe,IAAsBjB,EAAE,mBAAmB,QAAQ;AAAA,EAC9DD;AAAA,EACAG;AACF,CAAC,GAqCYgB,IAA2BlB,EAAE,MAAM;AAAA,EAC9CA,EACG,OAAO,EACP,WAAW,OAAO,EAClB,UAAiC,CAACmB,GAAOC,OAAS,EAAE,MAAM,YAAY,MAAMD,EAAM,MAAM,CAAC,IAAI;AAAA,EAChGT;AACF,CAAC,GAGYW,IAAyBrB,EAAE,MAAM;AAAA,EAC5CA,EAAE,OAAO,EAAE,UAA+B,CAACmB,GAAOC,MAC5CD,EAAM,WAAW,OAAO,IAAU,EAAE,MAAM,YAAY,MAAMA,EAAM,MAAM,CAAC,EAAE,IACnE,EAAE,MAAM,mBAAmB,SAASA,EAAM,CACvD;AAAA,EACDR;AACF,CAAC;ACrOM,SAASW,EACdC,GAGoD;AACpD,QAAMC,IAAgBD,EAAQ,SAAS,GAAG,IAAIA,IAAU,GAAGA,CAAO;AAClE,SAAO,CAA4BJ,MACjCA,EAAM,SAAS,aACX,EAAE,MAAM,gBAAgB,KAAKK,IAAgBL,EAAM,KAAA,IAClDA;AACT;ACNO,SAASM,EAA6CC,GAAsB;AACjF,SAAO1B,EAAE,MAAM;AAAA;AAAA,IAEb0B,EAAY,UAAU,CAACP,OAAW;AAAA,MAChC,MAAM;AAAA,MACN,MAAMA;AAAA,IAAA,EACN;AAAA;AAAA,IAEFnB,EAAE,mBAAmB,QAAQ;AAAA,MAC3BA,EAAE,OAAO;AAAA,QACP,MAAMA,EAAE,QAAQ,aAAa;AAAA,QAC7B,MAAM0B,EAAY,SAAS,eAAe;AAAA,MAAA,CAC3C;AAAA,IAAA,CACF;AAAA,EAAA,CACF;AACH;AAEgB,SAAAC,EAGdC,GAAwBC,GAAQ;AAChC,SAAO7B,EAAE,OAAO;AAAA,IACd,UAAU4B;AAAA,IACV,OAAOA;AAAA,IACP,IAAAC;AAAA,EAAA,CACD;AACH;AAEO,MAAMC,IAAgCH,EAAgB3B,EAAE,UAAUA,EAAE,QAAQ,GAGtE+B,IAA0BJ,EAAgBzB,GAAiBA,CAAe;AAGhF,SAAS8B,EAA2BC,GAAgB;AAClD,SAAAN;AAAA,IACLX,EAAsB,UAAUM,EAAoBW,CAAM,CAAC;AAAA,IAC3DjB,EAAsB,UAAUM,EAAoBW,CAAM,CAAC;AAAA,EAAA;AAE/D;ACzCa,MAAAC,IAASlC,EACnB,OAAA,EACA;AAAA,EACC;AAAA,EACA;AACF,GCLWmC,IAAcnC,EACxB,OAAO;AAAA,EACN,cAAcA,EAAE,OAAO;AAAA,EACvB,MAAMA,EAAE,OAAO;AAAA,EACf,SAASkC;AACX,CAAC,EACA,OAAO,GAGGE,IAAuBD,EAAY,KAAK,EAAE,SAAS,GAAM,CAAA;ACAtD,SAAAE,EAGdC,GAA4BC,GAAoB;AAChD,SAAOvC,EAAE,OAAO;AAAA,IACd,OAAOA,EAAE,OAAO;AAAA,IAChB,aAAaA,EAAE,OAAO;AAAA,IACtB,iBAAiBsC,EAAW,SAAS;AAAA,IACrC,MAAMC,EAAO,SAAS;AAAA,IACtB,KAAKvC,EAAE,OAAS,EAAA,IAAA,EAAM,SAAS;AAAA,IAC/B,MAAMA,EAAE,OAAS,EAAA,IAAA,EAAM,SAAS;AAAA,IAChC,SAASA,EAAE,MAAM,CAACA,EAAE,SAAS,OAAOA,EAAE,OAAS,EAAA,MAAA,CAAO,CAAC,EAAE,SAAS;AAAA,IAClE,MAAMA,EAAE,MAAMA,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,IACnC,cAAcA,EAAE,OAAO;AAAA,MACrB,MAAMA,EAAE,OAAO;AAAA,MACf,KAAKA,EAAE,OAAO,EAAE,IAAI;AAAA,MACpB,MAAMuC,EAAO,SAAS;AAAA,IAAA,CACvB;AAAA,EAAA,CACF;AACH;AAGO,MAAMC,IAA8BH;AAAA,EACzChB;AAAA,EACAH;AACF,GAIauB,IAAwBJ;AAAA,EACnCpB;AAAA,EACAD;AACF,GAIa0B,IAA+BL;AAAA,EAC1CrC,EAAE,OAAO;AAAA,EACTC;AACF,GCxCa0C,IAAyC3C,EAAE,OAAO;AAAA,EAC7D,YAAY8B;AAAA,EACZ,MAAMU;AACR,CAAC;AAEe,SAAAI,EAGdC,GAAwBC,GAAY;AACpC,SAAO9C,EAAE,OAAO;AAAA,IACd,IAAImC;AAAA,IACJ,YAAAU;AAAA,IACA,MAAAC;AAAA,EAAA,CACD;AACH;AAEO,MAAMC,IAA+BH;AAAA,EAC1Cb;AAAA,EACAU;AACF,GAGaO,IAA0BJ;AAAA,EACrCd;AAAA,EACAU;AACF,GAGaS,IAAmBjD,EAAE,OAAO;AAAA,EACvC,MAAMA,EAAE,OAAO;AAAA,EACf,MAAMA,EAAE,OAAO,EAAE,IAAI;AAAA,EACrB,QAAQA,EACL,OAAA,EACA,MAAM,aAAa,EACnB,YAAA,EACA,OAAO,EAAE;AAAA;AACd,CAAC,GAGYkD,IAAoBlD,EAAE,OAAO;AAAA,EACxC,QAAQA,EAAE,QAAQ,IAAI;AAAA,EACtB,aAAa+C;AAAA,EACb,OAAO/C,EAAE,MAAMiD,CAAgB;AACjC,CAAC;;;"}
+{"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"],"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\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal('absolute-file'),\n    file: z.string().startsWith('/').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      .startsWith('/')\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","import { z } from 'zod';\nimport { ContentRelativeBinary } from './content_types';\nimport { mapRemoteToAbsolute } from './content_conversion';\n\nexport type BlockPackComponents = {};\n\nexport function Workflow<const Content extends z.ZodTypeAny>(contentType: Content) {\n  return z.union([\n    // string is converted to v1 workflow\n    contentType.transform((value) => ({\n      type: 'workflow-v1',\n      main: value\n    })),\n    // structured objects are decoded as union with type descriptor\n    z.discriminatedUnion('type', [\n      z.object({\n        type: z.literal('workflow-v1'),\n        main: contentType.describe('Main workflow')\n      })\n    ])\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","import { z } from 'zod';\nimport {\n  ContentExplicitBase64,\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    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\n    })\n  });\n}\n\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedContent = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedContent = z.infer<typeof BlockPackMetaEmbeddedContent>;\n","import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta\n  });\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n","import { z } from 'zod';\nimport { BlockComponents } from './block_components';\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from './content_types';\nimport { CreateBlockPackDescriptionSchema } from './block_description';\nimport { BlockPackMeta } from './block_meta';\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: z\n    .string()\n    .regex(/[0-9a-fA-F]/)\n    .toUpperCase()\n    .length(64) // 256 / 4 (bits per hex register)\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  files: z.array(ManifestFileInfo)\n});\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = 'manifest.json';\n"],"names":["ContentExplicitString","z","ContentExplicitBase64","ContentRelative","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","Workflow","contentType","BlockComponents","wfAndModel","ui","BlockComponentsDescriptionRaw","BlockComponentsAbsoluteUrl","BlockPackMeta","longString","binary","BlockPackMetaDescriptionRaw","BlockPackMetaEmbeddedContent","BlockPackDescriptionFromPackageJsonRaw","CreateBlockPackDescriptionSchema","components","meta","BlockPackDescriptionRaw","BlockComponentsManifest","BlockPackMetaManifest","BlockPackDescriptionManifest","ManifestFileInfo","BlockPackManifest","BlockPackManifestFile"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-middle-layer",
-  "version": "1.2.20",
+  "version": "1.3.0",
   "description": "Common model between middle layer and non-block UI code",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -23,7 +23,7 @@
   },
   "devDependencies": {
     "typescript": "~5.5.4",
-    "vite": "^5.4.7",
+    "vite": "^5.4.8",
     "@milaboratories/platforma-build-configs": "1.0.1"
   },
   "scripts": {

package/src/block_meta/block_components.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ContentRelative, ContentRelativeBinary } from './content_types';
+import { ContentRelativeBinary } from './content_types';
 import { mapRemoteToAbsolute } from './content_conversion';
 
 export type BlockPackComponents = {};
@@ -26,7 +26,7 @@ export function BlockComponents<
   const UI extends z.ZodTypeAny
 >(wfAndModel: WfAndModel, ui: UI) {
   return z.object({
-    workflow: wfAndModel,
+    workflow: Workflow(wfAndModel),
     model: wfAndModel,
     ui
   });
@@ -35,9 +35,6 @@ export function BlockComponents<
 export const BlockComponentsDescriptionRaw = BlockComponents(z.string(), z.string());
 export type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;
 
-export const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);
-export type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;
-
 export function BlockComponentsAbsoluteUrl(prefix: string) {
   return BlockComponents(
     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),

package/src/block_meta/block_description.ts

@@ -0,0 +1,29 @@
+import { z, ZodTypeAny } from 'zod';
+import { BlockComponentsDescriptionRaw } from './block_components';
+import { BlockPackMetaDescriptionRaw } from './block_meta';
+import { BlockPackId } from './block_id';
+
+/** Description, as appears in root block package.json file,
+ * `file:` references are parsed into relative content of corresponding type, depending on the context,
+ * strings are converted to explicit content type. */
+export const BlockPackDescriptionFromPackageJsonRaw = z.object({
+  components: BlockComponentsDescriptionRaw,
+  meta: BlockPackMetaDescriptionRaw
+});
+
+export function CreateBlockPackDescriptionSchema<
+  Components extends ZodTypeAny,
+  Meta extends ZodTypeAny
+>(components: Components, meta: Meta) {
+  return z.object({
+    id: BlockPackId,
+    components,
+    meta
+  });
+}
+
+export const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(
+  BlockComponentsDescriptionRaw,
+  BlockPackMetaDescriptionRaw
+);
+export type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;