SambaPOS 3 Documentation

The engine works by iterating through the input script and categorizing segments into CodeBlock objects with specific State types: Html, Expression, CodeBlock, or Comment.

When Render() is called, the engine:

1. Parses the script into a buffer of these blocks.
2. Builds a final string that initializes a JavaScript variable buffer and uses string concatenation (+=) to append HTML segments and execute code blocks.

This results in a single executable string that can be used to build dynamic content.

The DefPlugin allows you to use the def keyword as an alias for the function keyword when declaring functions in FluentScript. This provides a more concise syntax for function definitions.

def add( a, b ) 
    {
        return a + b
    }

Once a type is registered via Register, you can instantiate it within the FluentScript environment using the Create method. You can provide an optional array of objects (object[] args) to serve as constructor arguments.

// Create an instance using the default parameterless constructor
object instance = registeredTypes.Create("MyCustomClass");

// Create an instance passing constructor arguments
object instanceWithArgs = registeredTypes.Create("MyCustomClass", new object[] { "arg1", 42 });

The TemplateEngineDefault class provides a templating engine with syntax similar to jQuery templates or Python-Django templates. It parses a script containing HTML and embedded code blocks (expressions, code blocks, or comments) and converts them into a JavaScript-like string concatenation format.

To use it, instantiate the engine with your script and call Render() to get the processed output.

var engine = new TemplateEngineDefault("<div><%= name %></div>");
string result = engine.Render();

The RegisteredTypes class allows you to bridge C# types into the FluentScript interpreter, enabling the language to call C# functions and interact with custom objects. You can register a type by providing its Type and a Func<object> creator that defines how a new instance of that type is instantiated.

Note: DateTime is treated as a basic type with a specialized creator that uses DateTime.Now.Ticks.

// Assuming an instance of RegisteredTypes named 'registeredTypes'
registeredTypes.Register(typeof(MyCustomClass), () => new MyCustomClass());

You can verify if a type is available in the interpreter and retrieve its underlying .NET Type using the following methods:

• Contains(string nameOrFullName): Returns true if the type (by short name or full name) is registered.
• Get(string nameOrFullName): Returns the System.Type associated with the provided name or full name.

if (registeredTypes.Contains("MyCustomClass"))
{
    Type type = registeredTypes.Get("MyCustomClass");
    // Proceed with logic using the retrieved Type
}

The TemplateEngineDefault engine uses specific delimiters to distinguish between plain text (HTML), expressions, code blocks, and comments:

Note: The engine treats everything outside these delimiters as standard HTML/text.

/* Syntax Reference */
<%= expression %> // Expression
<% code %>        // Code Block
<%- comment %>    // Comment
%%                 // Escape %

The CustomCommand class exposes the following properties for managing command state and display:

• Caption (string): The text label associated with the command, used for UI display.
• DataObject (object): The data context or object passed to the execution and validation methods.
• CanExecuteChanged (event): An event that notifies the UI when the command's execution status changes. It is wired to CommandManager.RequerySuggested to ensure automatic UI updates.

The ICategoryCommand interface is used to define commands that operate on or represent a specific category within the SambaPOS system. Any implementation of this interface must provide properties for the category name, its associated image source, and its display order. It inherits from ICaptionCommand, implying it also supports captioning functionality.

public interface ICategoryCommand : ICaptionCommand
{
    string Category { get; set; }
    string ImageSource { get; set; }
    int Order { get; set; }
}