@babylonjs/smart-filters 0.7.11-alpha → 0.7.13-alpha

package/src/utils/buildTools/{convertShaderForHardcodedBlock.ts → convertGlslIntoShaderProgram.ts}

@@ -1,6 +1,5 @@
 import * as fs from "fs";
-import * as path from "path";
-import { parseFragmentShader } from "./shaderConverter.js";
+import { parseFragmentShader, type FragmentShaderInfo } from "./shaderConverter.js";
 
 const TYPE_IMPORT_PATH = "@TYPE_IMPORT_PATH@";
 const VERTEX_SHADER = "@VERTEX_SHADER@";
@@ -13,6 +12,8 @@ const FUNCTIONS = "@FUNCTIONS@";
 const FUNCTION_NAME = "@FUNCTION_NAME@";
 const FUNCTION_CODE = "@FUNCTION_CODE@";
 const UNIFORM_NAMES = "@UNIFORM_NAMES@";
+const EXPORT = "@EXPORT_SHADER_PROGRAM@";
+const IMPORTS = "@IMPORT@";
 
 const ConstsTemplate = `
         const: \`${CONSTS_VALUE}\`,`;
@@ -29,12 +30,13 @@ const CodeLinePrefix = "                    ";
 const UniformLinePrefix = "            ";
 const ConstLinePrefix = "            ";
 
-const ShaderTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}";
+const ImportTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}";`;
+const ShaderTemplate = `${IMPORTS}
 
 /**
  * The shader program for the block.
  */
-export const shaderProgram: ShaderProgram = {
+${EXPORT}const shaderProgram: ShaderProgram = {
     vertex: ${VERTEX_SHADER},
     fragment: {
         uniform: \`${UNIFORMS}\`,${CONSTS_PROPERTY}
@@ -49,7 +51,7 @@ export const shaderProgram: ShaderProgram = {
  * The uniform names for this shader, to be used in the shader binding so
  * that the names are always in sync.
  */
-export const uniforms = {
+${EXPORT}const uniforms = {
 ${UNIFORM_NAMES}
 };
 `;
@@ -57,16 +59,51 @@ ${UNIFORM_NAMES}
 const UniformNameLinePrefix = "    ";
 
 /**
- * Converts a single shader to a .ts file which can be imported by a hardcoded block
+ * Converts a single shader to a .ts file which exports a ShaderProgram which can be imported by a hardcoded block
  * @param fragmentShaderPath - The path to the fragment file for the shader
  * @param importPath - The path to import the ShaderProgram type from
  */
-export function convertShaderForHardcodedBlock(fragmentShaderPath: string, importPath: string): void {
-    console.log(`Processing fragment shader: ${fragmentShaderPath}`);
+export function convertGlslIntoShaderProgram(fragmentShaderPath: string, importPath: string): void {
+    const { shaderProgramCode } = extractShaderProgramFromGlsl(fragmentShaderPath, importPath, true, true);
+    const shaderFile = fragmentShaderPath.replace(".glsl", ".ts");
+    fs.writeFileSync(shaderFile, shaderProgramCode);
+}
 
+/**
+ * Extracts the shader program from a glsl file(s) and returns it as a string which can be written to a .ts file
+ * @param fragmentShaderPath - The path to the fragment file for the shader
+ * @param importPath - The path to import the ShaderProgram type from
+ * @param exportObjects - Whether to export the shaderProgram and uniforms objects
+ * @param includeImports - Whether to include the imports in the output
+ * @returns The string to write to the .ts file
+ */
+export function extractShaderProgramFromGlsl(
+    fragmentShaderPath: string,
+    importPath: string,
+    exportObjects: boolean,
+    includeImports: boolean
+): {
+    /**
+     * The shader program code
+     */
+    shaderProgramCode: string;
+
+    /**
+     * The FragmentShaderInfo
+     */
+    fragmentShaderInfo: FragmentShaderInfo;
+} {
     // See if there is a corresponding vertex shader
     let vertexShader: string | undefined = undefined;
-    const vertexShaderPath = fragmentShaderPath.replace(".fragment.glsl", ".vertex.glsl");
+    let extensionToFind: string;
+    if (fragmentShaderPath.endsWith(".block.glsl")) {
+        extensionToFind = ".block.glsl";
+    } else if (fragmentShaderPath.endsWith(".fragment.glsl")) {
+        extensionToFind = ".fragment.glsl";
+    } else {
+        throw new Error("The shader file must end with .fragment.glsl or .block.glsl");
+    }
+    const vertexShaderPath = fragmentShaderPath.replace(extensionToFind, ".vertex.glsl");
     if (fs.existsSync(vertexShaderPath)) {
         vertexShader = fs.readFileSync(vertexShaderPath, "utf8");
     }
@@ -78,8 +115,7 @@ export function convertShaderForHardcodedBlock(fragmentShaderPath: string, impor
     const fragmentShader = fs.readFileSync(fragmentShaderPath, "utf8");
     const fragmentShaderInfo = parseFragmentShader(fragmentShader);
 
-    // Write the shader TS file
-    const shaderFile = fragmentShaderPath.replace(".fragment.glsl", ".shader.ts");
+    // Generate the shader program code
     const functionsSection: string[] = [];
     for (const shaderFunction of fragmentShaderInfo.shaderCode.functions) {
         functionsSection.push(
@@ -89,11 +125,12 @@ export function convertShaderForHardcodedBlock(fragmentShaderPath: string, impor
             )
         );
     }
+    const imports = includeImports ? ImportTemplate.replace(TYPE_IMPORT_PATH, importPath) : "";
     const finalContents = ShaderTemplate.replace(VERTEX_SHADER, vertexShader ? `\`${vertexShader}\`` : "undefined")
-        .replace(TYPE_IMPORT_PATH, importPath)
+        .replace(IMPORTS, imports)
         .replace(UNIFORMS, "\n" + addLinePrefixes(fragmentShaderInfo.shaderCode.uniform || "", UniformLinePrefix))
         .replace(MAIN_FUNCTION_NAME, fragmentShaderInfo.shaderCode.mainFunctionName)
-        .replace(MAIN_INPUT_NAME, fragmentShaderInfo.shaderCode.mainInputTexture || '""')
+        .replace(MAIN_INPUT_NAME, fragmentShaderInfo.shaderCode.mainInputTexture || "")
         .replace(
             CONSTS_PROPERTY,
             fragmentShaderInfo.shaderCode.const
@@ -110,29 +147,13 @@ export function convertShaderForHardcodedBlock(fragmentShaderPath: string, impor
                 fragmentShaderInfo.uniforms.map((u) => `${u.name}: "${u.name}",`).join("\n"),
                 UniformNameLinePrefix
             )
-        );
-
-    fs.writeFileSync(shaderFile, finalContents);
-}
-
-/**
- * Converts .fragment.glsl and vertex.glsl file pairs into .shader.ts files which export a ShaderProgram object.
- * @param shaderPath - The path to the .glsl files to convert.
- * @param importPath - The path to import the ShaderProgram type from.
- */
-export function convertShaders(shaderPath: string, importPath: string) {
-    // Get all files in the path
-    const allFiles = fs.readdirSync(shaderPath, { withFileTypes: true, recursive: true });
-
-    // Find all fragment shaders (excluding the template)
-    const fragmentShaderFiles = allFiles.filter(
-        (file) => file.isFile() && file.name.endsWith(".fragment.glsl") && !file.name.endsWith("template.fragment.glsl")
-    );
+        )
+        .replace(new RegExp(EXPORT, "g"), exportObjects ? "export " : "");
 
-    // Convert all shaders
-    for (const fragmentShaderFile of fragmentShaderFiles) {
-        convertShaderForHardcodedBlock(path.join(fragmentShaderFile.path, fragmentShaderFile.name), importPath);
-    }
+    return {
+        shaderProgramCode: finalContents,
+        fragmentShaderInfo,
+    };
 }
 
 /**

package/src/utils/buildTools/convertShaders.ts

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import * as path from "path";
+import { convertGlslIntoShaderProgram } from "./convertGlslIntoShaderProgram.js";
+import { convertGlslIntoBlock } from "./convertGlslIntoBlock.js";
+
+/**
+ * Converts all GLSL files in a path into blocks for use in the build system.
+ * @param shaderPath - The path to the .glsl files to convert.
+ * @param importPath - The path to import the ShaderProgram type from.
+ */
+export function convertShaders(shaderPath: string, importPath: string) {
+    // Get all files in the path
+    const allFiles = fs.readdirSync(shaderPath, { withFileTypes: true, recursive: true });
+
+    // Find all shaders (files with .fragment.glsl or .block.glsl extensions)
+    const shaderFiles = allFiles.filter(
+        (file) => file.isFile() && (file.name.endsWith(".fragment.glsl") || file.name.endsWith(".block.glsl"))
+    );
+
+    // Convert all shaders
+    for (const shaderFile of shaderFiles) {
+        const fullPathAndFileName = path.join(shaderFile.path, shaderFile.name);
+        convertShader(fullPathAndFileName, importPath);
+    }
+}
+
+/**
+ * Converts a single GLSL file into a block class or a ShaderProgram for use in the build system.
+ * @param fullPathAndFileName - The full path and file name of the .glsl file to convert.
+ * @param importPath - The path to import the ShaderProgram type from.
+ */
+export function convertShader(fullPathAndFileName: string, importPath: string): void {
+    console.log(`\nProcessing shader: ${fullPathAndFileName}`);
+
+    if (fullPathAndFileName.endsWith(".fragment.glsl")) {
+        console.log("Generating a .ts file that exports a ShaderProgram.");
+        convertGlslIntoShaderProgram(fullPathAndFileName, importPath);
+    } else if (fullPathAndFileName.endsWith(".block.glsl")) {
+        console.log("Generating a .ts file that exports the block as a class.");
+        convertGlslIntoBlock(fullPathAndFileName, importPath);
+    }
+}

package/src/utils/buildTools/shaderConverter.ts

@@ -1,5 +1,6 @@
 import type { Nullable } from "@babylonjs/core/types";
 import type { ShaderCode, ShaderFunction } from "./shaderCode.types";
+import { ConnectionPointType } from "../../connection/connectionPointType.js";
 
 const GetFunctionNamesRegEx = /\S*\w+\s+(\w+)\s*\(/g;
 
@@ -31,7 +32,7 @@ export type UniformMetadata = {
     /**
      * The type string of the uniform
      */
-    type: string;
+    type: ConnectionPointType;
 
     /**
      * Optional properties of the uniform
@@ -106,9 +107,34 @@ export function parseFragmentShader(fragmentShader: string): FragmentShaderInfo
             throw new Error(`Uniforms must have a name: '${uniformLine}'`);
         }
 
+        // Convert to ConnectionPointType
+        let type: ConnectionPointType;
+        switch (uniformTypeString) {
+            case "float":
+                type = ConnectionPointType.Float;
+                break;
+            case "sampler2D":
+                type = ConnectionPointType.Texture;
+                break;
+            case "vec3":
+                type = ConnectionPointType.Color3;
+                break;
+            case "vec4":
+                type = ConnectionPointType.Color4;
+                break;
+            case "bool":
+                type = ConnectionPointType.Boolean;
+                break;
+            case "vec2":
+                type = ConnectionPointType.Vector2;
+                break;
+            default:
+                throw new Error(`Unsupported uniform type: '${uniformTypeString}'`);
+        }
+
         uniforms.push({
             name: uniformName,
-            type: uniformTypeString,
+            type,
             properties: annotationJSON ? JSON.parse(annotationJSON.replace("//", "").trim()) : undefined,
         });
 

package/src/utils/buildTools/watchShaders.ts

@@ -6,9 +6,9 @@
  * @example node watchShaders.js <shaderPath> <importPath>
  */
 
-import { convertShaderForHardcodedBlock } from "./convertShaderForHardcodedBlock.js";
 import { watch } from "chokidar";
 import { extname } from "path";
+import { convertShader } from "./convertShaders.js";
 
 const externalArguments = process.argv.slice(2);
 if (externalArguments.length >= 2 && externalArguments[0] && externalArguments[1]) {
@@ -29,7 +29,7 @@ if (externalArguments.length >= 2 && externalArguments[0] && externalArguments[1
         // Wrap in try-catch to prevent the watcher from crashing
         // if the new shader changes are invalid
         try {
-            convertShaderForHardcodedBlock(file, importPath);
+            convertShader(file, importPath);
             console.log(`Successfully updated shader ${file}`);
         } catch (error) {
             console.error(`Failed to convert shader ${file}: ${error}`);

package/src/version.ts

@@ -1,4 +1,4 @@
 /**
  * The version of the SmartFilter core. During publish, this file is overwritten by versionUp.ts with the same version that is used for the NPM publish.
  */
-export const SmartFilterCoreVersion = "0.7.11-alpha";
+export const SmartFilterCoreVersion = "0.7.13-alpha";

package/dist/blockFoundation/outputBlock.shader.d.ts

@@ -1,13 +0,0 @@
-import type { ShaderProgram } from "../utils/shaderCodeUtils";
-/**
- * The shader program for the block.
- */
-export declare const shaderProgram: ShaderProgram;
-/**
- * The uniform names for this shader, to be used in the shader binding so
- * that the names are always in sync.
- */
-export declare const uniforms: {
-    input: string;
-};
-//# sourceMappingURL=outputBlock.shader.d.ts.map

package/dist/blockFoundation/outputBlock.shader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outputBlock.shader.d.ts","sourceRoot":"","sources":["../../src/blockFoundation/outputBlock.shader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,aAmB3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ;;CAEpB,CAAC"}

package/dist/blockFoundation/outputBlock.shader.js

@@ -1,31 +0,0 @@
-/**
- * The shader program for the block.
- */
-export const shaderProgram = {
-    vertex: undefined,
-    fragment: {
-        uniform: `
-            uniform sampler2D _input_; // main`,
-        mainInputTexture: "_input_",
-        mainFunctionName: "_copy_",
-        functions: [
-            {
-                name: "_copy_",
-                code: `
-                    vec4 _copy_(vec2 vUV) { 
-                        return texture2D(_input_, vUV);
-                    }
-                    
-                    `,
-            },
-        ],
-    },
-};
-/**
- * The uniform names for this shader, to be used in the shader binding so
- * that the names are always in sync.
- */
-export const uniforms = {
-    input: "input",
-};
-//# sourceMappingURL=outputBlock.shader.js.map

package/dist/blockFoundation/outputBlock.shader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"outputBlock.shader.js","sourceRoot":"","sources":["../../src/blockFoundation/outputBlock.shader.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAkB;IACxC,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE;QACN,OAAO,EAAE;+CAC8B;QACvC,gBAAgB,EAAE,SAAS;QAC3B,gBAAgB,EAAE,QAAQ;QAC1B,SAAS,EAAE;YACP;gBACI,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE;;;;;qBAKD;aACR;SACJ;KACJ;CACJ,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACpB,KAAK,EAAE,OAAO;CACjB,CAAC"}

package/dist/blockRegistration/IBlockRegistration.d.ts

@@ -1,36 +0,0 @@
-import type { ThinEngine } from "@babylonjs/core/Engines/thinEngine";
-import type { SmartFilter } from "../smartFilter";
-import type { BaseBlock } from "../blockFoundation";
-import type { SmartFilterDeserializer, ISerializedBlockV1 } from "../serialization";
-/**
- * An object which describes a block definition, as well as a factory for creating a new instance of the block or
- * deserializing it
- */
-export interface IBlockRegistration {
-    /**
-     * The block type of the block
-     */
-    blockType: string;
-    /**
-     * Creates an instance of the block, either fresh or deserialized from a serialized block
-     * @param smartFilter - The smart filter to create the block for
-     * @param engine - The engine to use for creating blocks
-     * @param smartFilterDeserializer - The deserializer to use for deserializing blocks
-     * @param serializedBlock - The serialized block to deserialize, if any
-     * @returns - A promise for a new instance of the block
-     */
-    factory?: (smartFilter: SmartFilter, engine: ThinEngine, smartFilterDeserializer: SmartFilterDeserializer, serializedBlock?: ISerializedBlockV1) => Promise<BaseBlock>;
-    /**
-     * The namespace of the block
-     */
-    namespace: string;
-    /**
-     * A tooltip for the block if displayed in an editor, for instance
-     */
-    tooltip: string;
-    /**
-     * If true, this represents a custom block (not one that was programmatically included)
-     */
-    isCustom?: boolean;
-}
-//# sourceMappingURL=IBlockRegistration.d.ts.map

package/dist/blockRegistration/IBlockRegistration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IBlockRegistration.d.ts","sourceRoot":"","sources":["../../src/blockRegistration/IBlockRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEpF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CACN,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,UAAU,EAClB,uBAAuB,EAAE,uBAAuB,EAChD,eAAe,CAAC,EAAE,kBAAkB,KACnC,OAAO,CAAC,SAAS,CAAC,CAAC;IAExB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB"}

package/dist/blockRegistration/IBlockRegistration.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=IBlockRegistration.js.map

package/dist/blockRegistration/IBlockRegistration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IBlockRegistration.js","sourceRoot":"","sources":["../../src/blockRegistration/IBlockRegistration.ts"],"names":[],"mappings":""}

package/dist/blockRegistration/blockSerializers.d.ts

@@ -1,13 +0,0 @@
-import type { IBlockSerializerV1 } from "../serialization/v1/smartFilterSerialization.types.js";
-/**
- * Any blocks that do not need to make use of ISerializedBlockV1.data can use the default serialization and
- * should go in this list. If the serializer needs to store additional info in ISerializedBlockV1.data (e.g.
- * webcam source name), then it should be registered in additionalBlockSerializers below.
- */
-export declare const blocksUsingDefaultSerialization: string[];
-/**
- * Any blocks which require serializing more information than just the connections should be registered here.
- * They should make use of the ISerializedBlockV1.data field to store this information.
- */
-export declare const additionalBlockSerializers: IBlockSerializerV1[];
-//# sourceMappingURL=blockSerializers.d.ts.map

package/dist/blockRegistration/blockSerializers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockSerializers.d.ts","sourceRoot":"","sources":["../../src/blockRegistration/blockSerializers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAkBhG;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,EAAE,MAAM,EAenD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,EAI1D,CAAC"}

package/dist/blockRegistration/blockSerializers.js

@@ -1,35 +0,0 @@
-import { blurBlockSerializer } from "../blocks/babylon/demo/effects/blurBlock.serializer.js";
-import { directionalBlurBlockSerializer } from "../blocks/babylon/demo/effects/directionalBlurBlock.serializer.js";
-import { compositionBlockSerializer } from "../blocks/babylon/demo/effects/compositionBlock.serializer.js";
-import { blackAndWhiteBlockType, pixelateBlockType, exposureBlockType, contrastBlockType, desaturateBlockType, posterizeBlockType, kaleidoscopeBlockType, greenScreenBlockType, maskBlockType, particleBlockType, spritesheetBlockType, tintBlockType, premultiplyAlphaBlockType, wipeBlockType, } from "../blocks/blockTypes.js";
-/**
- * Any blocks that do not need to make use of ISerializedBlockV1.data can use the default serialization and
- * should go in this list. If the serializer needs to store additional info in ISerializedBlockV1.data (e.g.
- * webcam source name), then it should be registered in additionalBlockSerializers below.
- */
-export const blocksUsingDefaultSerialization = [
-    blackAndWhiteBlockType,
-    pixelateBlockType,
-    exposureBlockType,
-    contrastBlockType,
-    desaturateBlockType,
-    posterizeBlockType,
-    kaleidoscopeBlockType,
-    greenScreenBlockType,
-    maskBlockType,
-    particleBlockType,
-    spritesheetBlockType,
-    tintBlockType,
-    premultiplyAlphaBlockType,
-    wipeBlockType,
-];
-/**
- * Any blocks which require serializing more information than just the connections should be registered here.
- * They should make use of the ISerializedBlockV1.data field to store this information.
- */
-export const additionalBlockSerializers = [
-    blurBlockSerializer,
-    directionalBlurBlockSerializer,
-    compositionBlockSerializer,
-];
-//# sourceMappingURL=blockSerializers.js.map

package/dist/blockRegistration/blockSerializers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockSerializers.js","sourceRoot":"","sources":["../../src/blockRegistration/blockSerializers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wDAAwD,CAAC;AAC7F,OAAO,EAAE,8BAA8B,EAAE,MAAM,mEAAmE,CAAC;AACnH,OAAO,EAAE,0BAA0B,EAAE,MAAM,+DAA+D,CAAC;AAE3G,OAAO,EACH,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,aAAa,GAChB,MAAM,yBAAyB,CAAC;AAEjC;;;;GAIG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAa;IACrD,sBAAsB;IACtB,iBAAiB;IACjB,iBAAiB;IACjB,iBAAiB;IACjB,mBAAmB;IACnB,kBAAkB;IAClB,qBAAqB;IACrB,oBAAoB;IACpB,aAAa;IACb,iBAAiB;IACjB,oBAAoB;IACpB,aAAa;IACb,yBAAyB;IACzB,aAAa;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAyB;IAC5D,mBAAmB;IACnB,8BAA8B;IAC9B,0BAA0B;CAC7B,CAAC"}

package/dist/blockRegistration/builtInBlockRegistrations.d.ts

@@ -1,13 +0,0 @@
-import type { IBlockRegistration } from "./IBlockRegistration.js";
-/**
- * The list of block registrations.
- *
- * Important notes:
- *   1. Do not import the block code directly in this file. Instead, use dynamic imports to ensure that the block code
- *      is only loaded when needed.
- *   2. If the deserializer is trivial (doesn't require consulting the serializedBlock.data), it can be implemented here
- *   3. If the deserializer is non-trivial (needs serializedBlock.data), implement it in a separate file alongside the block
- *      in the form blockClassName.deserializer.ts
- */
-export declare const builtInBlockRegistrations: IBlockRegistration[];
-//# sourceMappingURL=builtInBlockRegistrations.d.ts.map

package/dist/blockRegistration/builtInBlockRegistrations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtInBlockRegistrations.d.ts","sourceRoot":"","sources":["../../src/blockRegistration/builtInBlockRegistrations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AA+BlE;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,EA2VzD,CAAC"}