@babylonjs/smart-filters 0.7.3-alpha → 0.7.5-alpha

package/src/blocks/baseBlock.ts

@@ -29,6 +29,12 @@ export abstract class BaseBlock implements ICommandOwner {
      */
     public static ClassName = "BaseBlock";
 
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public static Namespace: Nullable<string> = null;
+
     /**
      * The smart filter the block belongs to.
      */
@@ -53,6 +59,15 @@ export abstract class BaseBlock implements ICommandOwner {
         return this.getClassName();
     }
 
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public get namespace(): Nullable<string> {
+        // Note that we use a static property instead of doing this.constructor.name to avoid problems with minifiers that would change the name of the class
+        return (this.constructor as typeof BaseBlock).Namespace;
+    }
+
     /**
      * User provided comments about the block. It can be used to document the block.
      */

package/src/blocks/customAggregateBlock.ts

@@ -3,14 +3,15 @@ import type { SmartFilterDeserializer, SerializedBlockDefinition } from "../seri
 import type { SmartFilter } from "../smartFilter.js";
 import { AggregateBlock } from "./aggregateBlock.js";
 import type { BaseBlock } from "./baseBlock.js";
+import type { Nullable } from "@babylonjs/core/types.js";
 
 /**
- * Loads a serialized SmartFilter into a block which can be used in another SmartFilter.
+ * Loads a serialized Smart Filter into a block which can be used in another SmartFilter.
  */
 export class CustomAggregateBlock extends AggregateBlock {
     /**
      * Creates a new CustomAggregateBlock
-     * @param smartFilter - The SmartFilter to create the block for
+     * @param smartFilter - The Smart Filter to create the block for
      * @param engine - The ThinEngine to use
      * @param name - The friendly name of the block
      * @param serializedSmartFilter - The serialized SmartFilter to load into the block
@@ -25,7 +26,14 @@ export class CustomAggregateBlock extends AggregateBlock {
         smartFilterDeserializer: SmartFilterDeserializer
     ): Promise<BaseBlock> {
         const innerSmartFilter = await smartFilterDeserializer.deserialize(engine, serializedSmartFilter);
-        return new CustomAggregateBlock(smartFilter, name, serializedSmartFilter.blockType, innerSmartFilter, false);
+        return new CustomAggregateBlock(
+            smartFilter,
+            name,
+            serializedSmartFilter.blockType,
+            serializedSmartFilter.namespace,
+            innerSmartFilter,
+            false
+        );
     }
 
     /**
@@ -34,6 +42,7 @@ export class CustomAggregateBlock extends AggregateBlock {
     public static override ClassName = "CustomAggregateBlock";
 
     private readonly _blockType: string;
+    private readonly _namespace: Nullable<string>;
 
     /**
      * The type of the block - used when serializing / deserializing the block, and in the editor.
@@ -42,16 +51,26 @@ export class CustomAggregateBlock extends AggregateBlock {
         return this._blockType;
     }
 
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public override get namespace(): Nullable<string> {
+        return this._namespace;
+    }
+
     private constructor(
         smartFilter: SmartFilter,
         name: string,
         blockType: string,
+        namespace: Nullable<string>,
         innerSmartFilter: SmartFilter,
         disableOptimization: boolean
     ) {
         super(smartFilter, name, disableOptimization);
 
         this._blockType = blockType;
+        this._namespace = namespace;
 
         const attachedBlocks = innerSmartFilter.attachedBlocks;
         for (let index = 0; index < attachedBlocks.length; index++) {
@@ -66,7 +85,7 @@ export class CustomAggregateBlock extends AggregateBlock {
                     );
                 }
 
-                // Remove this input block from the smart filter graph - this will reset the runtimeData to the
+                // Remove this input block from the Smart Filter graph - this will reset the runtimeData to the
                 // default for that connection point (which may be null)
                 innerSmartFilter.removeBlock(block);
                 index--;
@@ -79,7 +98,7 @@ export class CustomAggregateBlock extends AggregateBlock {
 
         this._registerSubfilterOutput("output", innerSmartFilter.output.connectedTo);
 
-        // Disconnect the inner smart filter output from the inner smart filter
+        // Disconnect the inner Smart Filter output from the inner Smart Filter
         innerSmartFilter.output.connectedTo.disconnectFrom(innerSmartFilter.output);
     }
 }

package/src/blocks/customShaderBlock.ts

@@ -101,6 +101,7 @@ export class CustomShaderBlock extends ShaderBlock {
             name,
             blockDefinition.disableOptimization,
             blockDefinition.blockType,
+            blockDefinition.namespace,
             blockDefinition.inputConnectionPoints,
             blockDefinition.shaderProgram
         );
@@ -113,6 +114,7 @@ export class CustomShaderBlock extends ShaderBlock {
 
     private readonly _shaderProgram: ShaderProgram;
     private readonly _blockType: string;
+    private readonly _namespace: Nullable<string>;
     private _autoBoundInputs: Nullable<SerializedInputConnectionPointV1[]> = null;
 
     /**
@@ -122,12 +124,21 @@ export class CustomShaderBlock extends ShaderBlock {
         return this._blockType;
     }
 
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public override get namespace(): Nullable<string> {
+        return this._namespace;
+    }
+
     /**
      * Instantiates a new custom shader block.
      * @param smartFilter - The smart filter this block belongs to
      * @param name - The name of the block
      * @param disableOptimization - If true, this optimizer will not attempt to optimize this block
      * @param blockType - The type of the block
+     * @param namespace - The namespace of the block
      * @param inputConnectionPoints - The input connection points of the
      * @param shaderProgram - The shader program for the block
      */
@@ -136,11 +147,13 @@ export class CustomShaderBlock extends ShaderBlock {
         name: string,
         disableOptimization: boolean,
         blockType: string,
+        namespace: Nullable<string>,
         inputConnectionPoints: SerializedInputConnectionPointV1[],
         shaderProgram: ShaderProgram
     ) {
         super(smartFilter, name, disableOptimization);
         this._blockType = blockType;
+        this._namespace = namespace;
 
         for (const input of inputConnectionPoints) {
             this._registerSerializedInputConnectionPointV1(input);

package/src/blocks/inputBlock.deserializer.ts

@@ -12,46 +12,85 @@ import type { ISerializedBlockV1 } from "../serialization/v1/smartFilterSerializ
  */
 export function inputBlockDeserializer(smartFilter: SmartFilter, serializedBlock: ISerializedBlockV1) {
     const blockData = serializedBlock.data as SerializedInputBlockData;
+    let inputBlock;
 
     switch (blockData.inputType) {
         case ConnectionPointType.Boolean:
-            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Boolean, blockData.value);
-        case ConnectionPointType.Float: {
-            const inputBlock = new InputBlock(
-                smartFilter,
-                serializedBlock.name,
-                ConnectionPointType.Float,
-                blockData.value
-            );
-            inputBlock.editorData = {
-                animationType: blockData.animationType,
-                valueDeltaPerMs: blockData.valueDeltaPerMs,
-                min: blockData.min,
-                max: blockData.max,
-            };
-            return inputBlock;
-        }
-        case ConnectionPointType.Texture: {
-            // Create the input block
-            const inputBlock = new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Texture, null);
+            {
+                inputBlock = new InputBlock(
+                    smartFilter,
+                    serializedBlock.name,
+                    ConnectionPointType.Boolean,
+                    blockData.value
+                );
+            }
+            break;
+        case ConnectionPointType.Float:
+            {
+                inputBlock = new InputBlock(
+                    smartFilter,
+                    serializedBlock.name,
+                    ConnectionPointType.Float,
+                    blockData.value
+                );
+                inputBlock.editorData = {
+                    animationType: blockData.animationType,
+                    valueDeltaPerMs: blockData.valueDeltaPerMs,
+                    min: blockData.min,
+                    max: blockData.max,
+                };
+            }
+            break;
+        case ConnectionPointType.Texture:
+            {
+                // Create the input block
+                inputBlock = new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Texture, null);
 
-            // If editor data was serialized, set it on the deserialized block
-            inputBlock.editorData = {
-                url: blockData.url,
-                urlTypeHint: blockData.urlTypeHint,
-                anisotropicFilteringLevel: blockData.anisotropicFilteringLevel,
-                flipY: blockData.flipY,
-                forcedExtension: blockData.forcedExtension,
-            };
-
-            return inputBlock;
-        }
+                // If editor data was serialized, set it on the deserialized block
+                inputBlock.editorData = {
+                    url: blockData.url,
+                    urlTypeHint: blockData.urlTypeHint,
+                    anisotropicFilteringLevel: blockData.anisotropicFilteringLevel,
+                    flipY: blockData.flipY,
+                    forcedExtension: blockData.forcedExtension,
+                };
+            }
+            break;
         case ConnectionPointType.Color3:
-            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Color3, blockData.value);
+            {
+                inputBlock = new InputBlock(
+                    smartFilter,
+                    serializedBlock.name,
+                    ConnectionPointType.Color3,
+                    blockData.value
+                );
+            }
+            break;
         case ConnectionPointType.Color4:
-            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Color4, blockData.value);
+            {
+                inputBlock = new InputBlock(
+                    smartFilter,
+                    serializedBlock.name,
+                    ConnectionPointType.Color4,
+                    blockData.value
+                );
+            }
+            break;
         case ConnectionPointType.Vector2:
-            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Vector2, blockData.value);
+            {
+                inputBlock = new InputBlock(
+                    smartFilter,
+                    serializedBlock.name,
+                    ConnectionPointType.Vector2,
+                    blockData.value
+                );
+            }
+            break;
+    }
+    if (inputBlock) {
+        inputBlock.appMetadata = blockData.appMetadata;
+
+        return inputBlock;
     }
 
     throw new Error("Could not deserialize input block, unknown input type");

package/src/blocks/inputBlock.serialization.types.ts

@@ -2,10 +2,21 @@ import type { Nullable } from "@babylonjs/core/types.js";
 import type { ConnectionPointType } from "../connection/connectionPointType.js";
 import type { IColor3Like, IColor4Like, IVector2Like } from "@babylonjs/core/Maths/math.like.js";
 
+/**
+ * Data that all serialized InputBlocks share
+ */
+export type CommonInputBlockData = {
+    /**
+     * Metadata the hosting app wants to track for this input. For example, a hint for what data to
+     * assign to this input, or hints about how to draw dynamic UI to allow users to control this value.
+     */
+    appMetadata: unknown;
+};
+
 /**
  * The data for an InputBlock for ConnectionPointType.Texture inputs
  */
-export type TextureInputBlockData = {
+export type TextureInputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Texture;
 
@@ -37,7 +48,7 @@ export type TextureInputBlockData = {
 /**
  * The data for an InputBlock for ConnectionPointType.Boolean inputs
  */
-export type BooleanInputBlockData = {
+export type BooleanInputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Boolean;
 
@@ -48,7 +59,7 @@ export type BooleanInputBlockData = {
 /**
  * The data for an InputBlock for ConnectionPointType.Float inputs
  */
-export type FloatInputBlockData = {
+export type FloatInputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Float;
 
@@ -79,7 +90,7 @@ export type FloatInputBlockData = {
 /**
  * The data for an InputBlock for ConnectionPointType.Color3 inputs
  */
-export type Color3InputBlockData = {
+export type Color3InputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Color3;
 
@@ -90,7 +101,7 @@ export type Color3InputBlockData = {
 /**
  * The data for an InputBlock for ConnectionPointType.Color4 inputs
  */
-export type Color4InputBlockData = {
+export type Color4InputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Color4;
 
@@ -101,7 +112,7 @@ export type Color4InputBlockData = {
 /**
  * The data for an InputBlock for ConnectionPointType.Vector2 inputs
  */
-export type Vector2InputBlockData = {
+export type Vector2InputBlockData = CommonInputBlockData & {
     /** The type of the input block */
     inputType: ConnectionPointType.Vector2;
 

package/src/blocks/inputBlock.serializer.ts

@@ -56,6 +56,7 @@ function serializeTextureInputBlock(inputBlock: InputBlock<ConnectionPointType.T
         flipY: internalTexture?.invertY ?? null,
         anisotropicFilteringLevel: internalTexture?.anisotropicFilteringLevel ?? null,
         forcedExtension: forcedExtension !== "" ? forcedExtension : null,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -68,6 +69,7 @@ function serializeBooleanInputBlock(inputBlock: InputBlock<ConnectionPointType.B
     return {
         inputType: ConnectionPointType.Boolean,
         value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -84,6 +86,7 @@ function serializeFloatInputBlock(inputBlock: InputBlock<ConnectionPointType.Flo
         valueDeltaPerMs: inputBlock.editorData?.valueDeltaPerMs ?? null,
         min: inputBlock.editorData?.min ?? null,
         max: inputBlock.editorData?.max ?? null,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -96,6 +99,7 @@ function serializeColor3InputBlock(inputBlock: InputBlock<ConnectionPointType.Co
     return {
         inputType: ConnectionPointType.Color3,
         value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -108,6 +112,7 @@ function serializeColor4InputBlock(inputBlock: InputBlock<ConnectionPointType.Co
     return {
         inputType: ConnectionPointType.Color4,
         value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -120,6 +125,7 @@ function serializeVector2InputBlock(inputBlock: InputBlock<ConnectionPointType.V
     return {
         inputType: ConnectionPointType.Vector2,
         value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
     };
 }
 
@@ -136,6 +142,7 @@ export const inputBlockSerializer: IBlockSerializerV1 = {
             name: block.name,
             uniqueId: block.uniqueId,
             blockType: InputBlockBase.ClassName,
+            namespace: null,
             comments: block.comments,
             data: serializeInputBlockData(block as unknown as InputBlockBase),
         };

package/src/blocks/inputBlock.ts

@@ -115,7 +115,7 @@ export type InputBlockEditorData<T extends ConnectionPointType> = T extends Conn
  *
  * The value is dynamically set by the user.
  */
-export class InputBlock<U extends ConnectionPointType> extends InputBlockBase {
+export class InputBlock<U extends ConnectionPointType, V = unknown> extends InputBlockBase {
     /**
      * The output connection point of the block.
      */
@@ -131,6 +131,12 @@ export class InputBlock<U extends ConnectionPointType> extends InputBlockBase {
      */
     public editorData: Nullable<InputBlockEditorData<U>> = null;
 
+    /**
+     * Metadata the hosting app wants to track for this input. For example, a hint for what data to
+     * assign to this input, or hints about how to draw dynamic UI to allow users to control this value.
+     */
+    public appMetadata: Nullable<V> = null;
+
     /**
      * Gets the current value of the input.
      */

package/src/connection/connectionPoint.ts

@@ -89,7 +89,7 @@ export class ConnectionPoint<U extends ConnectionPointType = ConnectionPointType
     }
 
     /**
-     * @returns the connection point this connection point is connected to.
+     * @returns The connection point this connection point is connected to.
      * (the one on the other side of the connection)
      * Only input connection points have a connected point which they received their value from.
      * (Relation is always 1:N for input:output)
@@ -99,8 +99,8 @@ export class ConnectionPoint<U extends ConnectionPointType = ConnectionPointType
     }
 
     /**
-     * @returns the connection point this connection point is to.
-     * (the one on the other side of the connection)
+     * @returns The connection points this output connection point is connected to.
+     * (the ones on the other side of the connection)
      * Only output connection points have a list of endpoints which they provide their value to.
      * (Relation is always 1:N for input:output)
      */

package/src/index.ts

@@ -39,3 +39,4 @@ export * from "./utils/textureLoaders.js";
 export * from "./serialization/index.js";
 export * from "./editorUtils/editableInPropertyPage.js";
 export * from "./serialization/importCustomBlockDefinition.js";
+export * from "./version.js";

package/src/serialization/importCustomBlockDefinition.ts

@@ -95,6 +95,7 @@ function importAnnotatedGlsl(fragmentShader: string): SerializedShaderBlockDefin
         format: "shaderBlockDefinition",
         formatVersion: 1,
         blockType: fragmentShaderInfo.blockType,
+        namespace: fragmentShaderInfo.namespace,
         shaderProgram: {
             fragment: fragmentShaderInfo.shaderCode,
         },

package/src/serialization/smartFilterDeserializer.ts

@@ -55,7 +55,6 @@ export class SmartFilterDeserializer {
         // Back-compat for the rename of version to formatVersion, didn't warrant a new version
         if ((serializedSmartFilter as any).version && serializedSmartFilter.formatVersion === undefined) {
             serializedSmartFilter.formatVersion = (serializedSmartFilter as any).version;
-            delete (serializedSmartFilter as any).version;
         }
 
         switch (serializedSmartFilter.formatVersion) {
@@ -68,7 +67,7 @@ export class SmartFilterDeserializer {
         engine: ThinEngine,
         serializedSmartFilter: SerializedSmartFilterV1
     ): Promise<SmartFilter> {
-        const smartFilter = new SmartFilter(serializedSmartFilter.name);
+        const smartFilter = new SmartFilter(serializedSmartFilter.name, serializedSmartFilter.namespace);
         const blockIdMap = new Map<number, BaseBlock>();
 
         // Only needed for smart filters saved before we started using uniqueIds for the maps, didn't warrant new version
@@ -164,6 +163,11 @@ export class SmartFilterDeserializer {
             serializedBlock.blockType = (serializedBlock as any).className;
         }
 
+        // Back compat for early Smart Filter V1 serialization where the namespace was not stored
+        if (serializedBlock.namespace === undefined) {
+            serializedBlock.namespace = null;
+        }
+
         // Get the instance of the block
         switch (serializedBlock.blockType) {
             case InputBlock.ClassName:
@@ -185,7 +189,9 @@ export class SmartFilterDeserializer {
                 // If it's not an input or output block, use the provided block factory
                 newBlock = await this._blockFactory(smartFilter, engine, serializedBlock, this);
                 if (!newBlock) {
-                    blockTypesWhichCouldNotBeDeserialized.push(serializedBlock.blockType);
+                    if (blockTypesWhichCouldNotBeDeserialized.indexOf(serializedBlock.blockType) === -1) {
+                        blockTypesWhichCouldNotBeDeserialized.push(serializedBlock.blockType);
+                    }
                     return;
                 }
             }

package/src/serialization/smartFilterSerializer.ts

@@ -111,6 +111,7 @@ export class SmartFilterSerializer {
             format: "smartFilter",
             formatVersion: 1,
             name: smartFilter.name,
+            namespace: smartFilter.namespace,
             comments: smartFilter.comments,
             editorData: smartFilter.editorData,
             blocks,

package/src/serialization/v1/defaultBlockSerializer.ts

@@ -12,6 +12,7 @@ export const defaultBlockSerializer: SerializeBlockV1 = (block: BaseBlock): ISer
         name: block.name,
         uniqueId: block.uniqueId,
         blockType: block.blockType,
+        namespace: block.namespace,
         comments: block.comments,
         data: undefined,
     };

package/src/serialization/v1/shaderBlockSerialization.types.ts

@@ -4,6 +4,7 @@
  * ----------------------------------------------------------------------------
  */
 
+import type { Nullable } from "@babylonjs/core/types";
 import type { AllConnectionPointTypes, ConnectionPointValue } from "../../connection/connectionPointType";
 import type { ShaderProgram } from "../../utils/shaderCodeUtils";
 
@@ -31,6 +32,12 @@ export type SerializedShaderBlockDefinitionV1 = {
      */
     blockType: string;
 
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    namespace: Nullable<string>;
+
     /**
      * The shader program for the block.
      */

package/src/serialization/v1/smartFilterSerialization.types.ts

@@ -24,6 +24,9 @@ export type SerializedSmartFilterV1 = {
     /** The SmartFilter name */
     name: string;
 
+    /** The namespace of the SmartFilter */
+    namespace: Nullable<string>;
+
     /** The SmartFilter comments */
     comments: Nullable<string>;
 
@@ -45,6 +48,9 @@ export interface ISerializedBlockV1 {
     /** The name of the block */
     name: string;
 
+    /** The namespace of the block */
+    namespace: Nullable<string>;
+
     /** The unique ID of the block - correlates with the ID in the editorData for block position, etc. */
     uniqueId: number;
 

package/src/smartFilter.ts

@@ -59,6 +59,11 @@ export class SmartFilter {
      */
     public readonly name: string;
 
+    /**
+     * The namespace of the smart filter.
+     */
+    public readonly namespace: Nullable<string>;
+
     /**
      * The smart filter output (input connection point of the output block...).
      *
@@ -85,9 +90,11 @@ export class SmartFilter {
     /**
      * Creates a new instance of a @see SmartFilter.
      * @param name - The friendly name of the smart filter
+     * @param namespace - The namespace of the smart filter
      */
-    constructor(name: string) {
+    constructor(name: string, namespace: Nullable<string> = null) {
         this.name = name;
+        this.namespace = namespace;
 
         this._attachedBlocks = new Array<BaseBlock>();
         this.outputBlock = new OutputBlock(this);

package/src/utils/buildTools/shaderConverter.ts

@@ -48,6 +48,11 @@ export type FragmentShaderInfo = {
      */
     blockType?: string;
 
+    /**
+     * If supplied, the namespace of the block
+     */
+    namespace: Nullable<string>;
+
     /**
      * If true, optimization should be disabled for this shader
      */
@@ -73,6 +78,7 @@ export function parseFragmentShader(fragmentShader: string): FragmentShaderInfo
     const { header, fragmentShaderWithoutHeader } = readHeader(fragmentShader);
     fragmentShader = fragmentShaderWithoutHeader;
     const blockType = header?.[SmartFilterBlockTypeKey] || undefined;
+    const namespace = header?.namespace || null;
 
     // Read the uniforms
     const uniforms: UniformMetadata[] = [];
@@ -167,6 +173,7 @@ export function parseFragmentShader(fragmentShader: string): FragmentShaderInfo
 
     return {
         blockType,
+        namespace,
         shaderCode,
         uniforms,
         disableOptimization: !!header?.disableOptimizer,
@@ -320,6 +327,11 @@ type GlslHeader = {
      */
     [SmartFilterBlockTypeKey]: string;
 
+    /**
+     * The namespace to use for the block
+     */
+    namespace?: string;
+
     /**
      * If true, optimization should be disabled for this shader
      */

package/src/utils/buildTools/versionUp.ts

@@ -41,6 +41,7 @@ queryNpmFeed("preview", (npmPreviewVersion) => {
 
         console.log("Version to use:", versionToUse);
 
+        // Update package.json if needed
         if (packageJSON.version !== versionToUse) {
             packageJSON.version = versionToUse;
             fs.writeFileSync("package.json", JSON.stringify(packageJSON, null, 4));
@@ -48,5 +49,12 @@ queryNpmFeed("preview", (npmPreviewVersion) => {
         } else {
             console.log("No need to update package.json");
         }
+
+        // Write out to version.ts
+        const versionTsText = `/**
+ * 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 = "${versionToUse}";\n`;
+        fs.writeFileSync("src/version.ts", versionTsText);
     });
 });

package/src/version.ts

@@ -0,0 +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.5-alpha";