knitwork-x
v0.3.1
Published
Utilities to generate JavaScript code.
Readme
🧶 knitwork-x
Utilities to generate JavaScript code.
forked from knitwork, and provide more comprehensive generation tools for typescript.
Install
# ✨ Auto-detect
npx nypm install knitwork-x
# npm
npm install knitwork-x
# yarn
yarn add knitwork-x
# pnpm
pnpm add knitwork-x
# bun
bun install knitwork-x
# deno
deno install npm:knitwork-xESM (Node.js, Bun, Deno)
import {} from 'knitwork-x'CommonJS (Legacy Node.js)
const {} = require('knitwork-x')CDN (Deno and Browsers)
import {} from 'https://esm.sh/knitwork-x'genArrowFunction(options)genAugmentation(specifier, statements?)genBlock(statements?, indent)genCallSignature(options)genCase(value, statements?, indent)genCatch(statements, options, indent)genClass(name, members, options, indent)genProperty(field, indent)genConditionalType(checkType, extendsType, trueType, falseType)genConstEnum(name, members, options, indent)genConstructor(parameters, body, options, indent)genConstructSignature(options)genDeclareNamespace(namespace, statements?)genDecorator(name, args?, indent)genDefault(statements?, indent)genDoWhile(statements, cond, options, indent)genElse(statements, options, indent)genElseIf(cond, statements, options, indent)genEnum(name, members, options, indent)genFinally(statements, options, indent)genFor(init, test, update, statements, options, indent)genForIn(left, obj, statements, options, indent)genForOf(left, iterable, statements, options, indent)genFunction(options, indent)genGetter(name, body, options, indent)genIf(cond, statements, options, indent)genIndexSignature(keyType, valueType, keyName)genInlineTypeImport(specifier, name, options)genInterface(name, contents?, options, indent)genIntersection(types)genKeyOf(type)genMappedType(keyName, keyType, valueType)genMethod(options, indent)genModule(specifier, statements?)genNamespace(name, statements?)genParam(p)genPrefixedBlock(prefix, statements, options, indent)genReturn(expr?, indent)genSatisfies(expr, type)genSetter(name, paramName, body, options, indent)genSwitch(expr, cases, options, indent)genTemplateLiteralType(parts)genTernary(cond, whenTrue, whenFalse)genThrow(expr, indent)genTry(statements, options, indent)genTypeAlias(name, value, options, indent)genTypeAssertion(expr, type)genTypeExport(specifier, imports, options)genTypeObject(object, indent)genTypeof(expr)genUnion(types)genVariable(name, value, options)genVariableName(name)genWhile(cond, statements, options, indent)
ESM
genDefaultExport(value, _options)
Generate an ESM export default statement.
Example:
genDefaultExport('foo')
// ~> `export default foo;`
genDefaultExport('42', { singleQuotes: true })
// ~> `export default 42;`genDynamicImport(specifier, options)
Generate an ESM dynamic import() statement.
Example:
genDynamicImport('pkg')
// ~> `import("pkg")`
genDynamicImport('pkg', { wrapper: true })
// ~> `() => import("pkg")`
genDynamicImport('pkg', { interopDefault: true })
// ~> `() => import("pkg").then(m => m.default || m)`
genDynamicImport('pkg', { type: true })
// ~> `typeof import("pkg")`
genDynamicImport('pkg', { type: true, name: 'foo' })
// ~> `typeof import("pkg").foo`genExport(specifier, exports?, options)
Generate an ESM export statement.
Example:
genExport('pkg', 'foo')
// ~> `export foo from "pkg";`
genExport('pkg', ['a', 'b'])
// ~> `export { a, b } from "pkg";`
genExport('pkg', '*')
// ~> `export * from "pkg";`
genExport('pkg', { name: '*', as: 'bar' })
// ~> `export * as bar from "pkg";`genImport(specifier, imports?, options)
Generate an ESM import statement.
Example:
genImport('pkg', 'foo')
// ~> `import foo from "pkg";`
genImport('pkg', ['foo'])
// ~> `import { foo } from "pkg";`
genImport('pkg', ['a', 'b'])
// ~> `import { a, b } from "pkg`;
genImport('pkg', [{ name: 'default', as: 'bar' }])
// ~> `import { default as bar } from "pkg`;
genImport('pkg', [{ name: 'foo', as: 'bar' }])
// ~> `import { foo as bar } from "pkg`;
genImport('pkg', 'foo', { attributes: { type: 'json' } })
// ~> `import foo from "pkg" with { type: "json" };
genImport('@nuxt/utils', ['test'], { type: true })
// ~> `import type { test } from "@nuxt/utils";`Serialization
genArray(array, indent, options)
Serialize an array to a string.
Values are not escaped or quoted.
Example:
genArray([1, 2, 3])
// ~> `[1, 2, 3]`genMap(entries, indent, options)
Serialize a Map to a string from raw entries.
Values are escaped and quoted if necessary (strings, etc.).
Example:
genMap([['foo', 'bar'], ['baz', 1]])
// ~> `new Map([["foo", "bar"], ["baz", 1]])`genObject(object, indent, options)
Serialize an object to a string.
Values are not escaped or quoted.
Example:
genObject({ foo: 'bar', test: '() => import("pkg")' })
// ~> `{ foo: bar, test: () => import("pkg") }`
genObject([{ name: 'foo', value: 'bar' }, { name: 'test', value: '() => import("pkg")' }])
// ~> `{ foo: bar, test: () => import("pkg") }`
genObject([{ name: 'count', value: '0', jsdoc: 'Counter value' }])
// ~> `{ /** Counter value *\/ count: 0 }`genSet(values, indent, options)
Serialize a Set to a string from raw values.
Values are escaped and quoted if necessary (strings, etc.).
Example:
genSet(['foo', 'bar', 1])
// ~> `new Set(["foo", "bar", 1])`String
escapeString(id)
Escape a string for use in a javascript string.
Example:
escapeString('foo\'bar')
// ~> `foo\'bar`
escapeString('foo\nbar')
// ~> `foo\nbar`genString(input, options)
Generate a string with double or single quotes and handle escapes.
Example:
genString('foo')
// ~> `"foo"`
genString('foo', { singleQuotes: true })
// ~> `'foo'`
genString('foo\nbar')
// ~> `"foo\nbar"`genTemplateLiteral(parts)
Generate runtime template literal: `hello ${x}` (value, not type).
Example:
genTemplateLiteral(['hello ', 'x'])
// ~> `` `hello ${x}` ``
genTemplateLiteral(['prefix', 'expr', 'suffix'])
// ~> `` `prefix${expr}suffix` ``
genTemplateLiteral(['', 'value'])
// ~> `` `${value}` ``
genTemplateLiteral(['text'])
// ~> `` `text` ``Typescript
genArrowFunction(options)
Generate arrow function: (params) => body or (params) => { statements }.
Example:
genArrowFunction({ body: 'x + 1' })
// ~> `() => x + 1`
genArrowFunction({ parameters: [{ name: 'x', type: 'number' }], body: 'x * 2' })
// ~> `(x: number) => x * 2`
genArrowFunction({ parameters: [{ name: 'x' }], body: ['return x + 1;'] })
// ~> `(x) => {\n return x + 1;\n}`
genArrowFunction({ parameters: [{ name: 'x', type: 'string' }], body: 'x.length', returnType: 'number' })
// ~> `(x: string): number => x.length`
genArrowFunction({ async: true, parameters: [{ name: 'url', type: 'string' }], body: ['return fetch(url);'] })
// ~> `async (url: string) => {\n return fetch(url);\n}`genAugmentation(specifier, statements?)
Generate typescript declare module augmentation.
Example:
genAugmentation('@nuxt/utils')
// ~> `declare module "@nuxt/utils" {}`
genAugmentation('@nuxt/utils', 'interface MyInterface {}')
// ~> `declare module "@nuxt/utils" { interface MyInterface {} }`
genAugmentation('@nuxt/utils', [
'interface MyInterface { test?: string }',
'type MyType = string',
])
// ~> multi-line declare module with both interface and typegenBlock(statements?, indent)
Generate a statement block { statements }.
Example:
genBlock()
// ~> `{}`
genBlock([])
// ~> `{}`
genBlock('return x;')
// ~> `{\n return x;\n}`
genBlock(['return x;'])
// ~> `{\n return x;\n}`
genBlock(['const a = 1;', 'return a;'])
// ~> `{\n const a = 1;\n return a;\n}`
genBlock(['return x;'], ' ')
// ~> `{\n return x;\n }`genCallSignature(options)
Generate call signature for interfaces.
Example:
genCallSignature({ parameters: [{ name: 'x', type: 'string' }], returnType: 'number' })
// ~> `(x: string): number`
genCallSignature({ parameters: [{ name: 'a', type: 'number' }, { name: 'b', type: 'number', optional: true }], returnType: 'void' })
// ~> `(a: number, b?: number): void`
genCallSignature({ generics: [{ name: 'T' }], parameters: [{ name: 'x', type: 'T' }], returnType: 'T' })
// ~> `<T>(x: T): T`genCase(value, statements?, indent)
Generate case value: optionally followed by indented statements (fall-through when omitted).
Example:
genCase('1', 'break;')
// ~> `case 1:\n break;`
genCase('\'a\'', ['doA();', 'break;'])
// ~> `case 'a':\n doA();\n break;`
genCase('0')
// ~> `case 0:` (fall-through)genCatch(statements, options, indent)
Generate catch (binding) { statements }, catch { statements }, or single-statement form.
Example:
genCatch(['throw e;'], { binding: 'e' })
// ~> `catch (e) { throw e; }`
genCatch(['logError();'])
// ~> `catch { logError(); }`
genCatch('handle(e);', { binding: 'e', bracket: false })
// ~> `catch (e) handle(e);`genClass(name, members, options, indent)
Generate class Name [extends Base] [implements I1, I2] { ... }.
Example:
genClass('Foo')
// ~> `class Foo {}`
genClass('Bar', [genConstructor([], ['super();'])])
// ~> `class Bar { constructor() { super(); } }`
genClass('Baz', [], { extends: 'Base', implements: ['I1', 'I2'] })
// ~> `class Baz extends Base implements I1, I2 {}`
genClass('Exported', [], { export: true })
// ~> `export class Exported {}`genConditionalType(checkType, extendsType, trueType, falseType)
Generate conditional type.
Example:
genConditionalType('T', 'U', 'X', 'Y')
// ~> `T extends U ? X : Y`
genConditionalType('T', 'null', 'never', 'T')
// ~> `T extends null ? never : T`genConstEnum(name, members, options, indent)
Generate typescript const enum (shorthand for genEnum with const: true).
Example:
genConstEnum('Direction', { Up: 1, Down: 2 })
// ~> `const enum Direction { Up = 1, Down = 2 }`
genConstEnum('Mode', { Read: 0, Write: 1 }, { export: true })
// ~> `export const enum Mode { Read = 0, Write = 1 }`genConstructor(parameters, body, options, indent)
Generate constructor(params) { [super(...);] ... }.
Example:
genConstructor()
// ~> `constructor() {}`
genConstructor([{ name: 'x', type: 'string' }], ['super();', 'this.x = x;'])
// ~> `constructor(x: string) { super(); this.x = x; }`
genConstructor([{ name: 'a', type: 'number' }, { name: 'b', type: 'number' }], ['super(a, b);'])
// ~> `constructor(a: number, b: number) { super(a, b); }`genConstructSignature(options)
Generate construct signature for interfaces.
Example:
genConstructSignature({ parameters: [{ name: 'x', type: 'string' }], returnType: 'MyClass' })
// ~> `new (x: string): MyClass`
genConstructSignature({ parameters: [{ name: 'value', type: 'number' }], returnType: 'Instance' })
// ~> `new (value: number): Instance`
genConstructSignature({ generics: [{ name: 'T' }], parameters: [{ name: 'x', type: 'T' }], returnType: 'T' })
// ~> `new <T>(x: T): T`genDeclareNamespace(namespace, statements?)
Generate typescript declare <namespace> block (e.g. declare global {}).
Example:
genDeclareNamespace('global')
// ~> `declare global {}`
genDeclareNamespace('global', 'interface Window {}')
// ~> `declare global { interface Window {} }`
genDeclareNamespace('global', [
'interface Window { customProp?: string }',
'const foo: string',
])
// ~> `declare global { interface Window {...} const foo: string }`genDecorator(name, args?, indent)
Generate decorator: @decorator or @decorator(args).
Example:
genDecorator('Component')
// ~> `@Component`
genDecorator('Injectable', '()')
// ~> `@Injectable()`
genDecorator('Route', '("/api")')
// ~> `@Route("/api")`
genDecorator('Validate', '(min: 0, max: 100)')
// ~> `@Validate(min: 0, max: 100)`genDefault(statements?, indent)
Generate default: optionally followed by indented statements.
Example:
genDefault('return 0;')
// ~> `default:\n return 0;`
genDefault(['log(\'default\');', 'break;'])
// ~> `default:\n log('default');\n break;`
genDefault()
// ~> `default:` (fall-through)genDoWhile(statements, cond, options, indent)
Generate do { body } while (cond); or single-statement form.
Example:
genDoWhile('step();', '!done')
// ~> `do { step(); } while (!done);`
genDoWhile(['read();', 'check();'], 'eof')
// ~> `do { read(); check(); } while (eof);`
genDoWhile('next();', 'hasMore', { bracket: false })
// ~> `do next(); while (hasMore);`genElse(statements, options, indent)
Generate else { statements } or else statement.
Example:
genElse(['return 0;'])
// ~> `else { return 0; }`
genElse('fallback();')
// ~> `else { fallback(); }`
genElse('doIt();', { bracket: false })
// ~> `else doIt();`genElseIf(cond, statements, options, indent)
Generate else if (cond) { statements } or else if (cond) statement.
Example:
genElseIf('x < 0', 'return -x;')
// ~> `else if (x < 0) { return -x; }`
genElseIf('ok', 'doIt();', { bracket: false })
// ~> `else if (ok) doIt();`genEnum(name, members, options, indent)
Generate typescript enum or const enum.
Example:
genEnum('Color', { Red: 0, Green: 1, Blue: 2 })
// ~> `enum Color { Red = 0, Green = 1, Blue = 2 }`
genEnum('Status', { Active: 'active', Inactive: 'inactive' })
// ~> `enum Status { Active = "active", Inactive = "inactive" }`
genEnum('Auto', { A: undefined, B: undefined, C: undefined })
// ~> `enum Auto { A = 0, B = 1, C = 2 }`
genEnum('MyEnum', { Foo: 1 }, { export: true, const: true })
// ~> `export const enum MyEnum { Foo = 1 }`genFinally(statements, options, indent)
Generate finally { statements } or finally statement.
Example:
genFinally('cleanup();')
// ~> `finally { cleanup(); }`
genFinally(['release();', 'log(\'done\');'])
// ~> `finally { release(); log('done'); }`
genFinally('cleanup();', { bracket: false })
// ~> `finally cleanup();`genFor(init, test, update, statements, options, indent)
Generate C-style for (init; test; update) { body } or single-statement form.
Example:
genFor('let i = 0', 'i < n', 'i++', 'console.log(i);')
// ~> `for (let i = 0; i < n; i++) { console.log(i); }`
genFor('', 'true', '', ['doWork();', 'if (done) break;'])
// ~> `for (; true; ) { doWork(); if (done) break; }`
genFor('i = 0', 'i < 10', 'i++', 'sum += i;', { bracket: false })
// ~> `for (i = 0; i < 10; i++) sum += i;`genForIn(left, obj, statements, options, indent)
Generate for (left in obj) { body } or single-statement form.
Example:
genForIn('const key', 'obj', 'console.log(key, obj[key]);')
// ~> `for (const key in obj) { console.log(key, obj[key]); }`
genForIn('const k', 'o', ['sum += o[k];'])
// ~> `for (const k in o) { sum += o[k]; }`
genForIn('let p', 'obj', 'visit(p);', { bracket: false })
// ~> `for (let p in obj) visit(p);`genForOf(left, iterable, statements, options, indent)
Generate for (left of iterable) { body } or single-statement form.
Example:
genForOf('const x', 'items', 'console.log(x);')
// ~> `for (const x of items) { console.log(x); }`
genForOf('let [k, v]', 'Object.entries(obj)', ['process(k, v);'])
// ~> `for (let [k, v] of Object.entries(obj)) { process(k, v); }`
genForOf('const item', 'list', 'yield item;', { bracket: false })
// ~> `for (const item of list) yield item;`genFunction(options, indent)
Generate typescript function declaration from Function.
Example:
genFunction({ name: 'foo' })
// ~> `function foo() {}`
genFunction({ name: 'foo', parameters: [{ name: 'x', type: 'string' }, { name: 'y', type: 'number', optional: true }] })
// ~> `function foo(x: string, y?: number) {}`
genFunction({ name: 'id', generics: [{ name: 'T' }], parameters: [{ name: 'x', type: 'T' }], returnType: 'T', body: ['return x;'] })
// ~> `function id<T>(x: T): T { return x; }`
genFunction({ name: 'foo', export: true })
// ~> `export function foo() {}`genGetter(name, body, options, indent)
Generate getter: get name() { ... } (for class or object literal).
Example:
genGetter('value', ['return this._v;'])
// ~> `get value() { return this._v; }`
genGetter('id', ['return this._id;'], { returnType: 'string' })
// ~> `get id(): string { return this._id; }`genIf(cond, statements, options, indent)
Generate if (cond) { statements } or if (cond) statement.
Example:
genIf('x > 0', 'return x;')
// ~> `if (x > 0) { return x; }`
genIf('ok', ['doA();', 'doB();'])
// ~> `if (ok) { doA(); doB(); }`
genIf('x', 'console.log(x);', { bracket: false })
// ~> `if (x) console.log(x);`genIndexSignature(keyType, valueType, keyName)
Generate index signature.
Example:
genIndexSignature('string', 'number')
// ~> `[key: string]: number`
genIndexSignature('number', 'string')
// ~> `[key: number]: string`
genIndexSignature('key', 'string', 'any')
// ~> `[key: string]: any`genInlineTypeImport(specifier, name, options)
Generate an typescript typeof import() statement for default import.
Example:
genInlineTypeImport('@nuxt/utils')
// ~> `typeof import("@nuxt/utils").default`
genInlineTypeImport('@nuxt/utils', 'genString')
// ~> `typeof import("@nuxt/utils").genString`genInterface(name, contents?, options, indent)
Generate typescript interface.
Example:
genInterface('FooInterface')
// ~> `interface FooInterface {}`
genInterface('FooInterface', { name: 'string', count: 'number' })
// ~> `interface FooInterface { name: string, count: number }`
genInterface('FooInterface', undefined, { extends: 'Other' })
// ~> `interface FooInterface extends Other {}`
genInterface('FooInterface', {}, { export: true })
// ~> `export interface FooInterface {}`genIntersection(types)
Generate intersection type.
Example:
genIntersection(['A', 'B'])
// ~> `A & B`
genIntersection(['A', 'B', 'C'])
// ~> `A & B & C`
genIntersection('string')
// ~> `string`genKeyOf(type)
Generate keyof type.
Example:
genKeyOf('T')
// ~> `keyof T`
genKeyOf('MyObject')
// ~> `keyof MyObject`genMappedType(keyName, keyType, valueType)
Generate mapped type.
Example:
genMappedType('K', 'keyof T', 'U')
// ~> `{ [K in keyof T]: U }`
genMappedType('P', 'keyof T', 'T[P]')
// ~> `{ [P in keyof T]: T[P] }`genMethod(options, indent)
Generate method (including get/set) with optional async/generator/static. For class or object literal: name(params) { body }, get name() { }, set name(v) { }.
Example:
genMethod({ name: 'foo' })
// ~> `foo() {}`
genMethod({ name: 'bar', parameters: [{ name: 'x', type: 'string' }], body: ['return x;'], returnType: 'string' })
// ~> `bar(x: string): string { return x; }`
genMethod({ name: 'value', kind: 'get', body: ['return this._v;'], returnType: 'number' })
// ~> `get value(): number { return this._v; }`
genMethod({ name: 'value', kind: 'set', parameters: [{ name: 'v', type: 'number' }], body: ['this._v = v;'] })
// ~> `set value(v: number) { this._v = v; }`genModule(specifier, statements?)
Generate typescript declare module block.
This is an alias for genAugmentation for consistency with TypeScript terminology.
Example:
genModule('@nuxt/utils')
// ~> `declare module "@nuxt/utils" {}`
genModule('@nuxt/utils', 'interface MyInterface {}')
// ~> `declare module "@nuxt/utils" { interface MyInterface {} }`genNamespace(name, statements?)
Generate typescript namespace block (non-declare; TS namespace).
Example:
genNamespace('MyNamespace')
// ~> `namespace MyNamespace {}`
genNamespace('MyNamespace', 'interface MyInterface {}')
// ~> `namespace MyNamespace { interface MyInterface {} }`
genNamespace('MyNamespace', [
'interface MyInterface { test?: string }',
'const foo: string',
])
// ~> `namespace MyNamespace { interface MyInterface {...} const foo: string }`genParam(p)
Generate a single function parameter string from Field.
Example:
genParam({ name: 'x', type: 'string' })
// ~> `x: string`
genParam({ name: 'y', type: 'number', optional: true })
// ~> `y?: number`
genParam({ name: 'z', type: 'number', default: '0' })
// ~> `z: number = 0`
genParam({ name: 'a' })
// ~> `a`genPrefixedBlock(prefix, statements, options, indent)
Low-level helper: generate prefix { statements } or prefix statement.
Example:
genPrefixedBlock('if (ok)', 'return true;')
// ~> `if (ok) { return true; }`
genPrefixedBlock('while (running)', ['step();', 'check();'])
// ~> `while (running) { step(); check(); }`
genPrefixedBlock('for (;;)', 'break;', { bracket: false })
// ~> `for (;;) break;`genProperty(field, indent)
Generate a single property signature from a TypeField. Returns [modifiers?][name][optional?]: [type][ = value]?. When field.jsdoc is set, prepends JSDoc comment. Supports static, readonly, public, private, protected (class property) and value (initializer).
Example:
genProperty({ name: 'foo', type: 'string' })
// ~> `foo: string`
genProperty({ name: 'bar', type: 'number', optional: true })
// ~> `bar?: number`
genProperty({ name: 'id', type: 'string', jsdoc: 'Unique id' }, ' ')
// ~> `/** Unique id *\/\n id: string`
genProperty({ name: 'x', value: '0' })
// ~> `x = 0`
genProperty({ name: 'id', type: 'string', readonly: true, static: true })
// ~> `static readonly id: string`genReturn(expr?, indent)
Generate return expr; or return;.
Example:
genReturn('x')
// ~> `return x;`
genReturn()
// ~> `return;`
genReturn('a + b')
// ~> `return a + b;`genSatisfies(expr, type)
Generate satisfies expression: expr satisfies Type (TS 4.9+).
Example:
genSatisfies('{ a: 1 }', '{ a: number }')
// ~> `{ a: 1 } satisfies { a: number }`
genSatisfies('config', 'ConfigType')
// ~> `config satisfies ConfigType`genSetter(name, paramName, body, options, indent)
Generate setter: set name(param) { ... } (for class or object literal).
Example:
genSetter('value', 'v', ['this._v = v;'])
// ~> `set value(v) { this._v = v; }`
genSetter('id', 'x', ['this._id = x;'], { paramType: 'string' })
// ~> `set id(x: string) { this._id = x; }`genSwitch(expr, cases, options, indent)
Generate switch (expr) { cases }.
Example:
genSwitch('x', [genCase('1', 'break;'), genDefault('return 0;')])
// ~> `switch (x) {\n case 1:\n break;\n default:\n return 0;\n}`
genSwitch('key', [])
// ~> `switch (key) {}`
genSwitch('n', [genCase('0'), genCase('1', 'return 1;')])
// ~> switch with fall-through case 0genTemplateLiteralType(parts)
Generate template literal type.
Example:
genTemplateLiteralType(['prefix', 'T', 'suffix'])
// ~> `` `prefix${T}suffix` ``
genTemplateLiteralType(['Hello ', 'T', ''])
// ~> `` `Hello ${T}` ``
genTemplateLiteralType(['', 'K', 'Key'])
// ~> `` `${K}Key` ``
genTemplateLiteralType(['prefix', 'T1', 'middle', 'T2', 'suffix'])
// ~> `` `prefix${T1}middle${T2}suffix` ``genTernary(cond, whenTrue, whenFalse)
Generate ternary expression cond ? whenTrue : whenFalse.
Example:
genTernary('x > 0', 'x', '-x')
// ~> `x > 0 ? x : -x`
genTernary('ok', '\'yes\'', '\'no\'')
// ~> `ok ? 'yes' : 'no'`genThrow(expr, indent)
Generate throw expr;.
Example:
genThrow('new Error(\'failed\')')
// ~> `throw new Error('failed');`
genThrow('e')
// ~> `throw e;`genTry(statements, options, indent)
Generate try { statements } or try statement.
Example:
genTry('mightThrow();')
// ~> `try { mightThrow(); }`
genTry(['const x = await f();', 'return x;'])
// ~> `try { const x = await f(); return x; }`
genTry('f();', { bracket: false })
// ~> `try f();`genTypeAlias(name, value, options, indent)
Create Type Alias
Example:
genTypeAlias('Foo', 'string')
// ~> `type Foo = string`
genTypeAlias('Bar', '{ a: number; b: string }')
// ~> `type Bar = { a: number; b: string }`
genTypeAlias('FooType', { name: 'string', count: 'number' })
// ~> `type FooType = { name: string, count: number }`
genTypeAlias('Baz', 'string', { export: true })
// ~> `export type Baz = string`
genTypeAlias('Id', 'T', { generics: [{ name: 'T' }] })
// ~> `type Id<T> = T`
genTypeAlias('Nullable', 'T | null', { generics: [{ name: 'T' }] })
// ~> `type Nullable<T> = T | null`genTypeAssertion(expr, type)
Generate type assertion: expr as Type.
Example:
genTypeAssertion('value', 'string')
// ~> `value as string`
genTypeAssertion('obj', 'MyType')
// ~> `obj as MyType`genTypeExport(specifier, imports, options)
Generate a typescript export type statement.
Example:
genTypeExport('@nuxt/utils', ['test'])
// ~> `export type { test } from "@nuxt/utils";`
genTypeExport('@nuxt/utils', [{ name: 'test', as: 'value' }])
// ~> `export type { test as value } from "@nuxt/utils";`genTypeObject(object, indent)
Generate typescript object type.
Example:
genTypeObject({ name: 'string', count: 'number' })
// ~> `{ name: string, count: number }`
genTypeObject({ 'key?': 'boolean' })
// ~> `{ key?: boolean }`
genTypeObject({ nested: { value: 'string' } })
// ~> `{ nested: { value: string } }`
genTypeObject([{ name: 'name', type: 'string' }, { name: 'count', type: 'number', required: true }])
// ~> `{ name?: string, count: number }`
genTypeObject([{ name: 'id', type: 'string', jsdoc: 'Unique id' }])
// ~> `{ /** Unique id *\/ id?: string }`genTypeof(expr)
Generate typeof type.
Example:
genTypeof('someVar')
// ~> `typeof someVar`
genTypeof('myFunction')
// ~> `typeof myFunction`genUnion(types)
Generate union type.
Example:
genUnion(['string', 'number'])
// ~> `string | number`
genUnion(['A', 'B', 'C'])
// ~> `A | B | C`
genUnion('string')
// ~> `string`genVariable(name, value, options)
Create variable declaration.
Example:
genVariable('a', '2')
// ~> `const a = 2`
genVariable('foo', '\'bar\'')
// ~> `const foo = 'bar'`
genVariable('x', '1', { kind: 'let' })
// ~> `let x = 1`
genVariable('y', '2', { export: true })
// ~> `export const y = 2`genVariableName(name)
Generate a safe javascript variable name.
Example:
genVariableName('valid_import')
// ~> `valid_import`
genVariableName('for')
// ~> `_for`
genVariableName('with space')
// ~> `with_32space`genWhile(cond, statements, options, indent)
Generate while (cond) { body } or single-statement form.
Example:
genWhile('running', 'step();')
// ~> `while (running) { step(); }`
genWhile('i > 0', ['process();', 'i--;'])
// ~> `while (i > 0) { process(); i--; }`
genWhile('ok', 'doIt();', { bracket: false })
// ~> `while (ok) doIt();`Utils
genComment(text, options: { block? }, indent)
Generate comment: single-line // or block comment (non-JSDoc).
Example:
genComment('Single line comment')
// ~> `// Single line comment`
genComment('Multi-line\ncomment', { block: true })
// ~> block comment format
genComment('Block comment', { block: true })
// ~> block comment format
genComment('Indented', ' ')
// ~> ` // Indented`genJSDocComment(jsdoc, indent)
Generate a JSDoc block comment from lines or a JSDoc object (typed interface).
Example:
genJSDocComment('Single line')
// ~> block comment with one line
genJSDocComment(['Line one', '@param x - number', '@returns void'])
// ~> multi-line block with those lines
genJSDocComment({ description: 'Fn', param: { x: 'number' }, returns: 'void' })
// ~> block with description, @param {number} x, @returns {void}
genJSDocComment('Indented', ' ')
// ~> same block, each line prefixed with indentgenKey(key)
Generate a safe javascript variable name for an object key.
Example:
genKey('foo')
// ~> `foo`
genKey('foo-bar')
// ~> `"foo-bar"`
genKey('with space')
// ~> `"with space"`genLiteral(fields, indent, _options)
Create object literal from field descriptors.
Example:
genLiteral(['type', ['type', 'A'], ['...', 'b']])
// ~> `{ type, type: A, ...b }`genRegExp(pattern, flags?)
Generate regex literal from pattern and flags.
Example:
genRegExp('foo')
// ~> `/foo/`
genRegExp('foo', 'gi')
// ~> `/foo/gi`
genRegExp('foo\\d+')
// ~> `/foo\d+/`wrapInDelimiters(lines, indent, delimiters, withComma)
Wrap an array of strings in delimiters.
Contribution
- Clone this repository
- Install the latest LTS version of Node.js
- Enable Corepack using
corepack enable - Install dependencies using
bun install - Run tests using
bun dev
License
Published under the MIT license. Made by @pi0, @danielroe and community 💛
🤖 auto updated with automd