@stylable/cli

@stylable/cli is a low-level utility used for working with Stylable projects directly.

• Build and transform stylesheets into JavaScript modules
• Generate an entry index file to help consume a published project

Installation

Using NPM:

npm install @stylable/cli --save-dev

Using Yarn:

yarn add @stylable/cli -D

Usage

After installing @stylable/cli, the stc command will be available, running stc --help will provide a brief description for the options available.

stc accepts CLI arguments or a Stylable configuration file.

CLI Arguments

Option	Alias	Description	Default Value
--version	v	show CLI version number	boolean
--rootDir		root directory of project	cwd
--srcDir		source directory relative to root	./
--outDir		target directory relative to root	./
--indexFile		filename of the generated index	false
--cjs		output commonjs modules (.js)	false
--esm		output esm modules (.mjs)	false
--css		output transpiled css files (.css)	false
--stcss		output stylable source files (.st.css)	false
--dts		output definition files for the stylable source files (.st.css.d.ts)	false
--dtsSourceMap		output source-maps for the definitions of stylable source files (.st.css.d.ts.map)	true if --dts is true, otherwise false
--watch	w	enable watch mode	false
--config	c	The path to a config file specifying how to build and output Stylable stylesheets	The directory containing the config file is assumed to be the "rootDir" for the project named "stylable.config.js"
--useNamespaceReference	unsr	mark output stylable source files with relative path for namespacing purposes (*)	false
--customGenerator		path of a custom index file generator	-
--ext		extension of stylable css files	.st.css
--cssInJs		output transpiled css into the js module	false
--cssFilename		pattern of the generated css file	[filename].css
--injectCSSRequest	icr	add a static import for the generated css in the js module output	false
--namespaceResolver	nsr	node request to a module that exports a stylable resolveNamespace function	@stylable/node
--require	r	require hook to execute before running	-
--optimize	o	removes: empty nodes, stylable directives, comments	false
--minify	m	minify generated css	false
--log		verbose log	false
--diagnostics		print verbose diagnostics	true
--diagnosticsMode		determine the diagnostics mode. if strict process will exit on any exception, loose will attempt to finish the process regardless of exceptions	false
--help	h	Show help	boolean

* - For the useNamespaceReference flag to function properly, the source folder must be published in addition to the output target code

Configuration file

The stc configuration should be located in the stylable.config.js file under the property name stcConfig. The CLI provides a helper method and type definitions to provide a better configuration experience.

const { stcConfig } = require('@stylable/cli');

// This can be an object or a method that returns an object.
exports.stcConfig = stcConfig({
    options: {
        // BuildOptions
    }
});

Build options

export interface BuildOptions {
    /** specify where to find source files */
    srcDir: string;
    /** specify where to build the target files */
    outDir: string;
    /** should the build need to output manifest file */
    manifest?: string;
    /** generates Stylable index file for the given name, the index file will reference Stylable sources from the `srcDir` unless the `outputSources` option is `true` in which case it will reference the `outDir` */
    indexFile?: string;
    /** custom cli index generator class */
    IndexGenerator?: typeof IndexGenerator;
    /** output commonjs module (.js) */
    cjs?: boolean;
    /** output esm module (.mjs) */
    esm?: boolean;
    /** template of the css file emitted when using outputCSS */
    outputCSSNameTemplate?: string;
    /** should include the css in the generated JS module */
    includeCSSInJS?: boolean;
    /** should output build css for each source file */
    outputCSS?: boolean;
    /** should output source .st.css file to dist */
    outputSources?: boolean;
    /** should add namespace reference to the .st.css copy  */
    useNamespaceReference?: boolean;
    /** should inject css import in the JS module for the generated css from outputCSS */
    injectCSSRequest?: boolean;
    /** should apply css optimizations */
    optimize?: boolean;
    /** should minify css */
    minify?: boolean;
    /** should generate .d.ts definitions for every stylesheet */
    dts?: boolean;
    /** should generate .d.ts.map files for every .d.ts mapping back to the source .st.css.
     * It will use the origin file path unless `outputSources` is true, then it will use the outputted file path as the source-map source.
     */
    dtsSourceMap?: boolean;
    /** should emit diagnostics */
    diagnostics?: boolean;
    /** determine the diagnostics mode. if strict process will exit on any exception, loose will attempt to finish the process regardless of exceptions */
    diagnosticsMode?: DiagnosticsMode;
}

Generating an index file

This generates an index.st.css file that acts as an export entry from every stylesheet in the provided srcDir.

$ stc --srcDir="./src" --outDir="./dist" --indexFile="index.st.css"

The generated index file will include re-exports of all stylesheet roots found in the given srcDir path.

Generating a custom index file

Exporting a Generator named export class from a file will allow it to be used as a customGenerator.

Usually this generator will inherit from our base generator class and override the generateReExports and generateIndexSource methods.

This example demonstrates the default generator behavior (only exports stylesheet roots):

import { Generator as Base, ReExports } from '@stylable/cli';

export class Generator extends Base {
    public generateReExports(filePath): ReExports {
        return {
            root: this.filename2varname(filePath),
            parts: {},
            keyframes: {},
            stVars: {},
            vars: {},
        };
    }    
    protected generateIndexSource(indexFileTargetPath: string) {
        const source = super.generateIndexSource(indexFileTargetPath);
        return '@st-namespace "INDEX";\n' + source;
    }
}

• See our named exports generator for a more complete example that re-exports every symbol from every stylesheet found in the generated index file.

Build source stylesheets to JavaScript modules

To transform your project stylesheets to target JavaScript modules containing the transformed source files, you must provide the indexFile parameter with an empty string.

$ stc --srcDir="./src" --outDir="./dist"

Multiple Projects

Projects allow sharing stc configurations and management of Stylable projects in one location. They provides a controllable and predictable build order with caching optimizations.

export interface MultipleProjectsConfig<PRESET extends string> {
    options?: PartialBuildOptions;
    presets?: Presets<PRESET>;
    projects: Projects<PRESET>;
    projectsOptions?: {
        resolveRequests?: ResolveRequests;
    };
}

Example for simple monorepo with Stylable packages

const { stcConfig } = require('@stylable/cli');

exports.stcConfig = stcConfig({
    options: {
        srcDir: './src',
        outDir: './dist',
        outputSources: true,
        cjs: false,
        useNamespaceReference: true, 
    },
    projects: ['packages/*']
});

Options

Similar to a single project, options is the top-level BuildOptions and is the default options for each project.

Projects

Projects is a generic term that refers to a set of path requests that define single or multiple BuildOptions.
This set of requests is being processed and then evaluated as a map of projectRoot (directory path) to a set of BuildOptions.

By default, the request is a path to a package, and in order to make the correct topological sort, the dependency needs to be specified in each package package.json

As mentioned above, the value of a request can be resolved to a single or multiple BuildOptions.

{
    //...
    projects: {
        "packages/*": { 
            // ...BuildOptions
        },
        "other-package/*": [
            { /* #1 ...BuildOptions */ }, 
            { /* #2 ...BuildOptions */ }, 
        ]
    }
    //...
}

The full types specification for defining Projects

export type Projects =
    | Array<string | [string, ProjectEntryValues]>
    | Record<string, ProjectEntryValues>;

export type ProjectEntryValues<PRESET extends string> =
    | ProjectEntryValue<PRESET>
    | Array<ProjectEntryValue<PRESET>>;

export type ProjectEntryValue<PRESET extends string> =
    | PRESET
    | PartialBuildOptions
    | {
          preset?: PRESET;
          presets?: Array<PRESET>;
          options: PartialBuildOptions;
      };

Presets

To reuse BuildOptions, define them using a name under the presets property and use them as the project entry value.

exports.stcConfig = {
    //...
    presets: {
        firstPreset: {/* ...BuildOptions */},
        secondPreset: {/* ...BuildOptions */},
    },
    projects: {
        'packages/*': ['firstPreset', 'secondPreset']
    }

};

Projects Options

These options control the projects resolution process.

resolveRequests [Function] (Advanced usage)

Default: resolveNpmRequests

This method is used to resolve the Projects requests (e.g. 'packages/*' in the example) to the actual projectRoots (absolute path to the relevant projects).

The order of the resolved entities will be the order of the builds.

Usage stc-format

After installing @stylable/cli, the stc-format command will be available, running stc-format --help will provide a brief description for the options available.

Option	Alias	Description	Value Type	Default Value
--target	T	file or directory to format	string	current working directory
--endWithNewline	n	End output with newline	boolean	false
--indentEmptyLines	E	Keep indentation on empty lines	boolean	false
--indentSize	s	Indentation size	number	4
--indentWithTabs	t	Indent with tabs, overrides -s and -c	boolean	false
--maxPerserveNewlines	m	Maximum number of line-breaks to be preserved in one chunk	number	1
--newlineBetweenRules	N	Add a newline between CSS rules	boolean	true
--perserveNewlines	p	Preserve existing line-breaks	boolean	true
--selectorSeparatorNewline	L	Add a newline between multiple selectors	boolean	true
--debug	D	Enable explicit debug log (overrides --silent)	boolean	false
--silent	S	Will not print any messages to the log	boolean	false
--require	r	require hooks	array	[]
--help	h	Show help	boolean
--version	v	Show version number	boolean

Experimental formatter

A new experimental formatter is available using the --experimental argument.

Currently not all configuration is accepted by the new formatter, the supported formatting options arguments are --endWithNewline, --indentSize, and a new --wrapLineLength.

Formatting the source directory

$ stc-format --target ./src

Usage stc-codemod

After installing @stylable/cli, the stc-codemod command will be available, running stc-codemod --help will provide a brief description for the options available.

Usage with npx

It is possible to run the codemod cli with npx with the following command

npx -p @stylable/cli stc-codemod --help

Option	Alias	Description	Value Type	Default Value
--rootDir	d	Root directory of a project	string	current working directory
--mods	m	Array of builtin codemods to execute	array	[]
--external	e	Array of external codemod requests to execute	array	[]
--require	r	require hooks	array	[]
--help	h	Show help	boolean

builtin codemods

• st-import-to-at-import - Convert :import to @st-import syntax.

Note that this codemod does not preserve comments inside the :import

• st-global-custom-property-to-at-property - Convert deprecated @st-global-custom-property *; to @property st-global(*); syntax.

• namespace-to-st-namespace - Converts @namespace that would have been used as Stylable namespace configuration to @st-namespace.

Provide an external codemod

Codemods are transformation operations for code based on AST.

The contract for external codemods is that any requested module (cjs) will provide a module.export.codemods which is an iterable with the following signature:

interface CodeModResponse {
    changed: boolean;
}

type Codemods = Iterable<{ id: string, apply: CodeMod }>;

type CodeMod = (context: CodeModContext) => CodeModResponse;

interface CodeModContext {
    ast: Root;
    diagnostics: Diagnostics;
    postcss: Postcss;
}

Codemod ids should be namespaced to avoid collision.

Basic codemod example

module.exports.codemods = [
    {
        id: 'banner', 
        apply({ ast, postcss }) { 
            ast.prepend(postcss.comment({text: 'Hello Codemod'}));
            
            return {
                changed: true
            }
        }
    }
]

License

Copyright (c) 2017 Wix.com Ltd. All Rights Reserved. Use of this source code is governed by a MIT license.