miniscript-vs

A toolkit for MiniScript that provides features like syntax highlighting, code execution, bundling, and minification. For the latest changes, check the changelog.

Prefer a different editor? The MiniScript language server is also available and works with IDEs like Sublime Text, IntelliJ, nvim, and more. Setup examples are included in the repository.

Usage

The plugin automatically detects .ms files.

Available commands (CTRL+SHIFT+P):

• MiniScript: Build - info

You can also access most commands from the context menu.

Plugin Settings:

• Autocomplete: Activate/Deactivate
• Diagnostic: Activate/Deactivate
• Hoverdocs: Activate/Deactivate
• Formatter: Activate/Deactivate
• Transpiler Settings:
  • Build Type: Default, Uglify, Beautify
  • Beautify
    • Indentation: Tab or whitespace. What should be used for indentation?
    • Indentation Spaces: In case whitespace is used this will determine the amount of whitespaces.
    • Keep Parentheses: Will always use parentheses.
  • Literals Optimizations: Activate/Deactivate
  • Namespaces Optimizations: Activate/Deactivate
  • Environment Variables: JSON used to define environment variables (ENVs)
  • Excluded Namespaces: List of namespaces that should not be optimized
  • Obfuscation: Enables minification of namespaces using special characters
• Interpreter Settings:
  • Environment Variables: JSON used to define environment variables (ENVs)
  • Silence Error Popups: Silences error popups due to execution failure
• Type Analyzer
  • Strategy: Specifies which files are used for type resolution. The "Dependency" strategy resolves types from all files imported into the current file. Alternatively, the "Workspace" strategy resolves types from all files within the workspace.
  • Exclude: Specifies files to ignore based on matching glob patterns.

Features

• Syntax Highlighting
• Transform
• Build
• Interpreter
• Debugger
• Comment Docs
• Goto Error
• Providers

Build

Transforms and bundles your files. It has three possible transformation types (Default, Uglify and Beautify) and supports environment variables as well.

Dependency Management (Transpiler)

This extension enables you to split your code into different files which is useful to keep readability and also to make reusable code.

Cyclic dependencies will be detected as well. In case there is one an error will be thrown indicating which file is causing it.

Import

Used to import exported namespaces from a file. Features of this import functionality:

• supports relative imports
• only loads code when required
• does not pollute global scope
• only gets imported once regardless of how many times it got imported
• only exports what you want

You can take a look at the example code to get a better idea of how to use this feature.

Include

Used to import the content of a file. Features of this import functionality:

• supports relative includes
• very easy to use
• will pollute global scope
• will include the content of a file every time, which may cause redundant code

To get a better idea you can take a look at the following example code.

Environment Variables (Transpiler)

This extension supports the injection of environment variables while transpiling. The environment variables can be configured by using the extension settings.

Here is an example of environment variable injection.

Syntax

Keep in mind that the following syntax is not valid in MiniScript. The transpiler can be used to transform code into valid MiniScript.

No trailing comma is required in maps or lists

myList = [
	false,
	null
]

myMap = {
	"test": {
		"level2": {
			"bar": true
		}
	}
}

Block comment

/*
	My block comment
*/
print("test")

Transform

Transform is pretty much a simplified build. It will only transform the file at hand and ignore any imports.

Interpreter

Executes MiniScript code. Supports all default MiniScript intrinsics. Also features a debugger.

Dependency Management (Interpreter)

Dependencies will be dynamically loaded into the execution without any limitations. Cyclic dependencies are supported as well.

Environment Variables (Interpreter)

This extension supports the injection of environment variables while executing code. The environment variables can be configured by using the extension settings.

Here is an example of environment variable injection.

Debugger

Enables you to set breakpoints, run code in a breakpoint context, jump to the next line of execution etc. Generally helpful if you want to debug your code.

Keep in mind to set the breakpoint on a non-empty line. Otherwise, it will just skip that breakpoint.

A REPL is also available while executing the script or having an active breakpoint.

Comment Docs

You can add function signatures in your comments to improve the developer experience.

• Hover tooltips will display parameter and return type information.
• The type system can use these annotations to provide context-sensitive autocomplete suggestions.

Example:

// Hello world
// I am **bold**
// @description Alternative description
// @example test("title", 123)
// @param {string} test - Some text.
// @param {string|number} abc - Some text.
// @returns {crypto} - Some info about the return value
test = function(test, abc)
  print(test)
end function

Custom Types

You can also define your own types and describe their properties. These types can then be used as return values or extended in other places.

// @type Bar
// @property {string} virtualMoo
// @property {string} nested.virtualMoo
Bar = {}
Bar.moo = ""

// @description Example with parameters
// @param {string} test
// @param {string|number} abc
// @returns {Bar} - Some info about the return value
Bar.test = function(test, abc)
  print("test")
  return self
end function

// @type Foo
Foo = new Bar

// @returns {Foo}
Foo.New = function(message)
  result = new Foo
  return result
end function

myVar = Foo.New

// Hover/autocomplete results:
// myVar.test → shows signature of Bar.test
// myVar.virtualMoo → recognized as string
// myVar.nested.virtualMoo → recognized as string

Virtual Custom Types

Sometimes you want to describe types that exist only in documentation and tooling, without needing a runtime implementation. These are called virtual types.

They can include properties, functions, and even inherit from other virtual types.

// @vtype myOtherType
// @property {map<string,string>} hallo

// @vtype myCustomType
// @extends myOtherType
// @function foo
  // @params {string} bar
  // @returns {string}
  // @description This is a custom type with a function
  // @example Example usage of myCustomType
// @property {number} myProperty

// @define {myCustomType}
bar = {}

// Hover/autocomplete results:
// bar.foo → shows signature of myCustomType.foo

Refresh

Will refresh the AST Cache which is used for diagnostics, hover tooltips and autocompletion.

Goto Error

Jumps to the next existing syntax error.

Supporting providers

This extension includes several IntelliSense providers to enhance your coding experience with GreyScript:

• Autocompletion Provider
  Offers context-aware suggestions based on your current position in the code.

• Signature Helper Provider
  Displays function signatures with parameter types and return values as you type, helping you use functions correctly and efficiently without needing to reference documentation.

• Hover Tooltips Provider
  Displays helpful information about functions and types when you hover over them.

• Diagnostics Provider
  Identifies and highlights syntax errors in your code for easier debugging.

• Symbol Provider
  Lists all symbols available in the active file for easy navigation.
  

• Definition Provider
  Locates and displays definitions within the active file and its dependencies.
  

• Color Picker Provider
  Shows a color picker when you use color or mark tags in your code.