slice2ts
v0.2.4
Published
Compiles Slice files to TypeScript.
Downloads
4,180
Readme
slice2ts
Compiles Slice files to TypeScript.
Installation
$ npm install -D slice2ts
Usage
Usage: slice2ts [options] <file ...>
Options:
-V, --version output the version number
--root-dir <dir> Root dirs.
Output files will have the same structure as source files relative to root dirs.
Ice includes are also resolved in these dirs.
-e, --exclude <file> File paths or globs to exclude.
-o, --out-dir <dir> Directory where to put generated files.
--no-js If true, only the typings are generated.
--ice-imports If true, Ice modules are imported from particular files instead of "ice".
-i, --ignore <type> Don't generate typings for these types.
--index If true, generates index file for each top-level slice module.
--no-nullable-values If true, don't generate `| null` for fields and parameters whose type is Value.
-h, --help output usage information
API
import {slice2ts} from 'slice2ts';
slice2ts(options); // Promise<void>;
Options interface:
{
/**
* Array of slice file paths or globs.
*/
files: string[];
/**
* Array of file paths or globs to exclude.
*/
exclude?: string[];
/**
* Array of root dirs.
* Output files will have the same structure as source files relative to root
* dirs.
* Ice includes are also resolved in these dirs.
*/
rootDirs: string[];
/**
* Directory where to put generated files.
*/
outDir: string;
/**
* If true, only typings are generated.
*/
noJs?: boolean;
/**
* If true, Ice modules are imported from particular files instead of "ice".
*/
iceImports?: boolean;
/**
* Don't generate typings for these types.
*/
ignore?: string[];
/**
* If true, generates index file for each top-level slice module.
*/
index?: boolean;
/**
* If true, don't generate `| null` for fields and parameters whose type is
* Value.
*/
noNullableValues?: boolean;
}
Metadata Directives
ts:type:<type>
Overrides generated type for fields, operation parameters or operation return values:
class AbstractBase {}; class A extends AbstractBase {}; class B extends AbstractBase {}; struct S { ["ts:type:A|B"] AbstractBase field; }; class C { ["ts:type:A|B"] AbstractBase field1; ["ts:type:A|B"] optional(1) AbstractBase field2; }; interface I { ["ts:type:A|B"] AbstractBase operation( ["ts:type:A|B"] AbstractBase arg1, ["ts:type:A|B"] optional(1) AbstractBase arg2 ); };
Outputs:
class AbstractBase extends Ice.Value {} class A extends AbstractBase {} class B extends AbstractBase {} class S implements Ice.Struct { constructor(field?: A | B); field: A | B; clone(): this; equals(other: this): boolean; hashCode(): number; } class C extends Ice.Value { constructor(field1?: A | B, field2?: A | B | undefined); field1: A | B; field2?: A | B; } abstract class I extends Ice.Object { abstract operation( arg1: A | B, arg2: A | B | undefined, current: Ice.Current, ): Ice.OperationResult<A | B>; } class IPrx extends Ice.ObjectPrx { operation( arg1: A | B, arg2?: A | B, ctx?: Ice.Context, ): Ice.AsyncResult<A | B>; }
ts:generic:<type parameters>
Adds generic parameters for types generated from sequences, dictionaries, classes and interfaces:
["ts:generic:T extends Ice.Value"] sequence<["ts:type:T"] Object> GenericSeq; ["ts:generic:T extends Ice.Value"] dictionary<string, ["ts:type:T"] Object> GenericDict; ["ts:generic:T extends Ice.Value"] class GenericClass { ["ts:type:T"] Object field; }; ["ts:generic:T extends Ice.Value"] interface GenericInterface { ["ts:type:GenericClass<T>"] GenericClass operation( ["ts:type:GenericSeq<T>"] GenericSeq arg ); };
Outputs:
type GenericSeq<T extends Ice.Value> = Array<T>; type GenericDict<T extends Ice.Value> = Map<string, T>; const GenericDict: { new <T extends Ice.Value>(entries?: ReadonlyArray<[string, T]>): Map< string, T >; }; class GenericClass<T extends Ice.Value> extends Ice.Value { constructor(field?: T); field: T; } abstract class GenericInterface<T extends Ice.Value> extends Ice.Object { abstract operation( arg: GenericSeq<T>, current: Ice.Current, ): Ice.OperationResult<GenericClass<T>>; } class GenericInterfacePrx<T extends Ice.Value> extends Ice.ObjectPrx { operation( arg: GenericSeq<T>, ctx?: Ice.Context, ): Ice.AsyncResult<GenericClass<T>>; }