asconfig.json

Add a file named asconfig.json in the root folder of your project to enable the ActionScript & MXML extension for Visual Studio Code. This file configures the project for code intelligence in the editor, and it stores the compiler options used to build the project and options for packaging an Adobe AIR application.

The asconfigc utility can also use the same asconfig.json file to compile your project from the command line.

Examples

An example asconfig.json file for an Apache Royale project appears below:

{
	"compilerOptions": {
		"targets": [
			"JSRoyale"
		],
		"source-path": [
			"src"
		],
		"source-map": true
	},
	"mainClass": "HelloRoyale"
}

For a complete tutorial, see Create a new ActionScript project in Visual Studio Code that targets Apache Royale.

Here's another sample asconfig.json file for a pure ActionScript project targeting Adobe AIR on mobile:

{
	"config": "airmobile",
	"compilerOptions": {
		"source-path": [
			"src"
		],
		"output": "bin/HelloAIR.swf"
	},
	"mainClass": "HelloAIR",
	"application": "src/HelloAIR-app.xml",
	"airOptions": {
		"android": {
			"output": "bin/HelloAIR.apk",
			"signingOptions": {
				"storetype": "pkcs12",
				"keystore": "android_certificate.p12"
			}
		},
		"ios": {
			"output": "bin/HelloAIR.ipa",
			"signingOptions": {
				"storetype": "pkcs12",
				"keystore": "ios_certificate.p12",
				"provisioning-profile": "example.mobileprovision"
			}
		}
	}
}

For a complete tutorial, see Create a new ActionScript project in Visual Studio Code that targets Adobe AIR for mobile platforms.

Top-Level Properties

config

The default configuration file to use from the SDK.

{
	"config": "airmobile"
}

The following values for "config" are supported:

"flex"
"air"
"airmobile"
"royale" (Apache Royale only)
"js" (Apache Royale only)
"node" (Apache Royale only)

When compiling Apache Royale projects, "royale" is the default value. For all other SDKs, "flex" is the default.

type

The type of project being built. Defaults to "app".

{
	"type": "lib"
}

The following values for "type" are supported:

"app" - an application
"lib" - a library (SWC)

mainClass

The main entry point of an application project.

{
	"mainClass": "Main"
}

Resolved using the values specified using the source-path compiler option. The following example will try to find either src/Main.as or src/Main.mxml.

{
	"compilerOptions": {
		"source-path": [
			"src"
		]
	},
	"mainClass": "Main"
}

files

The specified source files will be included in the compiled output, including all of their dependencies — even if they are not referenced anywhere else. If the mainClass field is omitted in an application project, the final item in the files array will be used as the application entry point.

{
	"files": [
		"src/MyProject.as"
	]
}

The files property is for source files only (.as and .mxml files). If you are building an Adobe AIR application and you want to include extra asset files in your package, they should not be added here. See Adobe AIR options for details about how to include extra asset files with your application.

application

Optional path to an Adobe AIR application descriptor file. When compiling, the descriptor's <content> element will be automatically populated, and the file will be copied into the output folder.

In the simplest case, you may specify a single application descriptor file for all platforms:

{
	"application": "src/MyProject-app.xml"
}

Alternatively, you may specify separate application descriptor files for each platform:

{
	"application": {
		"ios": "src/MyProjectIOS-app.xml",
		"android": "src/MyProjectAndroid-app.xml",
		"windows": "src/MyProjectWindows-app.xml",
		"mac": "src/MyProjectMacOS-app.xml"
	}
}

Warning: If the output folder overlaps with the source path, the application descriptor will not be copied.

extends

References another asconfig.json file to use as a template, allowing some of the values to be overridden.

{
	"extends": "./asconfig.other.json"
}

See example of extends.

compilerOptions

Specify command line options to instruct the compiler how to build the project.

{
	"compilerOptions": {
		"output": "bin/MyApp.swf",
		"library-path": [
			"libs"
		]
	}
}

See Compiler Options below for complete details.

additionalOptions

Additional options to send to the compiler, formatted as command line arguments. Useful for testing new or advanced compiler options that are not yet supported within the compilerOptions field of asconfig.json.

You may specify additional options as a single string:

{
	"additionalOptions": "-cool-new-option=true -another-option+=path/to/something"
}

If you prefer, you may specify additional options as an array of strings instead:

{
	"additionalOptions": [
		"-cool-new-option=true",
		"-another-option+=path/to/something"
	]
}

airOptions

Specify command line options to instruct the AIR Developer Tool (ADT) how to package an Adobe AIR application.

{
	"airOptions": {
		"output": "bin/MyApp.air",
		"signingOptions": {
			"storetype": "pkcs12",
			"keystore": "path/to/certificate.p12"
		}
	}
}

See Adobe AIR Options below for complete details.

copySourcePathAssets

Copies all files in the source path that don't have .as or .mxml extensions into the output folder.

{
	"copySourcePathAssets": true
}

For Adobe AIR apps, the files will be copied to the output folder, but they will not be included in the packaged app. Use the files field to include specific files or folders.

Warning: If the output folder overlaps with the source path, no files will be copied.

htmlTemplate

Copies a folder containing a template for HTML that embeds a .swf file to the output folder. Files such as index.template.html containing tokens like ${bgcolor} will be populated automatically based on the project's compiler options.

{
	"htmlTemplate": "./html-template"
}

The values for the following tokens will be populated based on your compiler options:

default-background-color populates ${bgcolor}. Defaults to #ffffff.
default-size populates ${width} and ${height}. Defaults to 100% for both values.
target-player populates ${version_major}, ${version_minor}, and ${version_revision}. Defaults to 9.0.124.
output populates ${swf}.
The name of your main class populates ${application}.

Your workspace's SDK should contain a number of supported templates that you may copy into your project's workspace. For instance, many SDKs contain a template that uses SWFObject at <SDK path>/template/swfobject.

modules

One or more modules that will be compiled along with the application.

{
	"modules": [
		{
			"file": "src/MyModule.mxml",
			"output": "bin/MyModule.swf",
			"optimize": true
		},
		{
			"file": "src/AnotherModule.mxml",
			"output": "bin/AnotherModule.swf",
			"optimize": true
		}
	]
}

See example of modules.

workers

One or more SWF workers that will be compiled along with the application.

{
	"workers": [
		{
			"file": "src/MyWorker.as",
			"output": "bin/MyWorker.swf"
		},
		{
			"file": "src/AnotherWorker.as",
			"output": "bin/AnotherWorker.swf"
		}
	]
}

See example of workers.

Compiler Options

The following options apply to all projects. See Library Compiler Options, JavaScript Compiler Options, or SWF Compiler Options for options that are specific to different project types.

benchmark

Prints detailed compile times to the standard output. The default value is true.

"compilerOptions": {
	"benchmark": true
}

debug

The generated output of the build will contain extra debug data.

"compilerOptions": {
	"debug": true
}

When building an ActionScript project inside Visual Studio Code, the debug compiler option in asconfig.json will be ignored because you can choose between debug or release from the list of tasks.

define

Defines a global constant at compile time. May be a boolean, number, string, or expression.

"define": [
	{
		"name": "CONFIG::debugging",
		"value": true
	},
	{
		"name": "CONFIG::release",
		"value": false
	}
]

For boolean and numeric values, you may pass in literals like true, false, or 123. String values must be formatted with nested quotes, like "'hello'", because the compiler will attempt to evaluate an expression when it encounters quotes.

dump-config

Combines all configuration options and saves them to the specified file.

"compilerOptions": {
	"dump-config": "path/to/dumped-config.xml"
}

external-library-path

Specifies a list of .swc files, .ane files, or folders containing .swc or .ane files, to exclude from linking in the generated output. This option provides compile-time link checking for external components that are dynamically linked.

"compilerOptions": {
	"external-library-path": [
		"typedefs"
	]
}

Warning: Some ActionScript compilers require that you add each .ane file to external-library-path separately, while other compilers can also search for .ane files inside folders. For maximum compatibility, it's better to specify individual .ane files in the external-library-path. All compilers can search folders for .swc files, so this applies to native extensions only.

This option supports the ${flexlib} and ${royalelib} tokens to reference files from the frameworks folder inside the project's SDK.

keep-all-type-selectors

Disables the pruning of unused type selectors. The default value is false.

"compilerOptions": {
	"keep-all-type-selectors": true
}

library-path

Specifies a list of .swc files, .ane files, or folders containing .swc or .ane files to link into the generated output of the build. The compiler only links in those classes that are referenced.

"compilerOptions": {
	"library-path": [
		"libs",
		"path/to/file.swc",
		"another_file.ane"
	]
}

Warning: Some ActionScript compilers require that you add each .ane file to library-path separately, while other compilers can also search for .ane files inside folders. For maximum compatibility, it's better to specify individual .ane files in the library-path. All compilers can search folders for .swc files, so this applies to native extensions only.

This option supports the ${flexlib} and ${royalelib} tokens to reference files from the frameworks folder inside the project's SDK.

load-config

Specifies the locations of XML configuration files that define extra compiler options.

"compilerOptions": {
	"load-config": [
		"path/to/project-config.xml"
	]
}

load-externs

Specifies the locations of XML files that define extra symbols to omit from the output.

"compilerOptions": {
	"load-externs": [
		"path/to/externs.xml"
	]
}

namespace

Specifies MXML namespaces. Each namespace must include a URI and the location of the manifest file that defines the contents of the namespace.

"compilerOptions": {
	"namespace": [
		{
			"uri": "http://ns.example.com",
			"manifest": "manifest.xml"
		},
		{
			"uri": "library://example.com/library",
			"manifest": "path/to/library-manifest.xml"
		},
	]
}

output

The path where the generated output should be saved.

"compilerOptions": {
	"output": "bin/MyApp.swf"
}

show-unused-type-selector-warnings

Determines if warnings generated from unused CSS type selectors are displayed. The default value is true.

"compilerOptions": {
	"show-unused-type-selector-warnings": false
}

size-report

Generates a report that summarizes the size of each type of data in the application and saves it to the specified output file.

"compilerOptions": {
	"size-report": "path/to/size-report.xml"
}

source-path

Adds folders or files to the source path. The compiler searches folders in the source path for .mxml, .as, or .css source files that are used in your applications and includes those that are required at compile time.

"compilerOptions": {
	"source-path": [
		"src"
	]
}

This option supports the ${flexlib} and ${royalelib} tokens to reference files from the frameworks folder inside the project's SDK.

strict

Performs compile-time type checking on assignments and options supplied to method calls. The default value is true.

"compilerOptions": {
	"strict": false
}

theme

Specifies a theme file to use with this application.

"compilerOptions": {
	"theme": "path/to/Theme.swc"
}

warnings

Enables or disables all warnings.

"compilerOptions": {
	"warnings": false
}

Library Compiler Options

The following options apply only when compiling library projects.

include-classes

Specifies classes to include in the .swc file. You provide the class name (for instance, com.example.MyClass) rather than the file name (for instance, com/example/MyClass.as) to the file for this option.

"compilerOptions": {
	"include-classes": [
		"com.example.SomeClass",
		"com.example.utils.AnotherClass"
	]
}

include-file

Specifies a list of files to include in the .swc file. Each entry in this array must be an object with two fields, file and path. The file field refers to the source location of a file on your computer. The path field refers to the destination location of the file inside the .swc library.

"compilerOptions": {
	"include-file": [
		{
			"file": "path/to/myfile.png",
			"path": "myfile.png"
		}
	]
}

include-namespaces

Specifies namespace-style components in the .swc file. You specify a list of URIs to include in the .swc file. The uri argument must also be defined with the namespace option.

"compilerOptions": {
	"include-namespaces": [
		"http://ns.example.com",
		"library://example.com/library"
	]
}

include-sources

Specifies classes or folders to add to the .swc file. When specifying classes, you specify the path to the class file (for instance, com/example/MyClass.as) rather than the fully-qualified class name (such as com.example.MyClass).

"compilerOptions": {
	"include-sources": [
		"source",
		"third-party/library"
	]
}

JavaScript Compiler Options

The following compiler options apply only when transpiling ActionScript to JavaScript with Apache Royale.