From 583db23c985091070bef1e90faf8f697a5604b46 Mon Sep 17 00:00:00 2001 From: Eugene Lazutkin Date: Mon, 25 Jun 2018 22:42:52 -0500 Subject: [PATCH] stream-json: split modules, followed lint suggestions. --- types/stream-json/Assembler.d.ts | 37 ++ types/stream-json/Emitter.d.ts | 23 + types/stream-json/Parser.d.ts | 35 ++ types/stream-json/Stringer.d.ts | 30 ++ types/stream-json/filters/Filter.d.ts | 26 + types/stream-json/filters/FilterBase.d.ts | 29 ++ types/stream-json/filters/Ignore.d.ts | 26 + types/stream-json/filters/Pick.d.ts | 26 + types/stream-json/filters/Replace.d.ts | 26 + types/stream-json/index.d.ts | 487 +----------------- types/stream-json/stream-json-tests.ts | 14 +- types/stream-json/streamers/StreamArray.d.ts | 26 + types/stream-json/streamers/StreamBase.d.ts | 17 + types/stream-json/streamers/StreamObject.d.ts | 26 + types/stream-json/streamers/StreamValues.d.ts | 26 + types/stream-json/tsconfig.json | 3 +- types/stream-json/utils/emit.d.ts | 7 + types/stream-json/utils/withParser.d.ts | 47 ++ 18 files changed, 438 insertions(+), 473 deletions(-) create mode 100644 types/stream-json/Assembler.d.ts create mode 100644 types/stream-json/Emitter.d.ts create mode 100644 types/stream-json/Parser.d.ts create mode 100644 types/stream-json/Stringer.d.ts create mode 100644 types/stream-json/filters/Filter.d.ts create mode 100644 types/stream-json/filters/FilterBase.d.ts create mode 100644 types/stream-json/filters/Ignore.d.ts create mode 100644 types/stream-json/filters/Pick.d.ts create mode 100644 types/stream-json/filters/Replace.d.ts create mode 100644 types/stream-json/streamers/StreamArray.d.ts create mode 100644 types/stream-json/streamers/StreamBase.d.ts create mode 100644 types/stream-json/streamers/StreamObject.d.ts create mode 100644 types/stream-json/streamers/StreamValues.d.ts create mode 100644 types/stream-json/utils/emit.d.ts create mode 100644 types/stream-json/utils/withParser.d.ts diff --git a/types/stream-json/Assembler.d.ts b/types/stream-json/Assembler.d.ts new file mode 100644 index 0000000000..52282d7beb --- /dev/null +++ b/types/stream-json/Assembler.d.ts @@ -0,0 +1,37 @@ +import { EventEmitter } from 'events'; +import { Readable } from 'stream'; + +export = Assembler; + +interface Token { + name: string; + value?: string; +} + +declare class Assembler extends EventEmitter { + constructor(); + + connectTo(stream: Readable): this; + consume(chunk: Token): this; + dropToLevel(level: number): this; + + current: any; + key: string | null; + stack: Array; + readonly done: boolean; + + readonly depth: number; + readonly path: string; + + // events + addListener(event: 'done', listener: (asm: Assembler) => void): this; + on(event: 'done', listener: (asm: Assembler) => void): this; + once(event: 'done', listener: (asm: Assembler) => void): this; + prependListener(event: 'done', listener: (asm: Assembler) => void): this; + prependOnceListener(event: 'done', listener: (asm: Assembler) => void): this; + removeListener(event: 'done', listener: (asm: Assembler) => void): this; +} + +declare namespace Assembler { + function connectTo(stream: Readable): Assembler; +} diff --git a/types/stream-json/Emitter.d.ts b/types/stream-json/Emitter.d.ts new file mode 100644 index 0000000000..7d0a3138c2 --- /dev/null +++ b/types/stream-json/Emitter.d.ts @@ -0,0 +1,23 @@ +import { Writable, WritableOptions } from 'stream'; + +export = Emitter; + +declare class Emitter extends Writable { + constructor(options?: WritableOptions); +} + +declare namespace Emitter { + function make(options?: WritableOptions): Emitter; + + namespace make { + type Constructor = Emitter; + const Constructor: typeof Emitter; + } + + function emitter(options?: WritableOptions): Emitter; + + namespace emitter { + type Constructor = Emitter; + const Constructor: typeof Emitter; + } +} diff --git a/types/stream-json/Parser.d.ts b/types/stream-json/Parser.d.ts new file mode 100644 index 0000000000..5fc689936e --- /dev/null +++ b/types/stream-json/Parser.d.ts @@ -0,0 +1,35 @@ +import { Transform, TransformOptions } from 'stream'; + +export = Parser; + +declare class Parser extends Transform { + constructor(options?: Parser.ParserOptions); +} + +declare namespace Parser { + interface ParserOptions extends TransformOptions { + packValues?: boolean; + packKeys?: boolean; + packStrings?: boolean; + packNumbers?: boolean; + streamValues?: boolean; + streamKeys?: boolean; + streamStrings?: boolean; + streamNumbers?: boolean; + jsonStreaming?: boolean; + } + + function make(options?: ParserOptions): Parser; + + namespace make { + type Constructor = Parser; + const Constructor: typeof Parser; + } + + function parser(options?: ParserOptions): Parser; + + namespace parser { + type Constructor = Parser; + const Constructor: typeof Parser; + } +} diff --git a/types/stream-json/Stringer.d.ts b/types/stream-json/Stringer.d.ts new file mode 100644 index 0000000000..6ada77a37a --- /dev/null +++ b/types/stream-json/Stringer.d.ts @@ -0,0 +1,30 @@ +import { Transform, TransformOptions } from 'stream'; + +export = Stringer; + +declare class Stringer extends Transform { + constructor(options?: Stringer.StringerOptions); +} + +declare namespace Stringer { + interface StringerOptions extends TransformOptions { + useValues?: boolean; + useKeyValues?: boolean; + useStringValues?: boolean; + useNumberValues?: boolean; + } + + function make(options?: StringerOptions): Stringer; + + namespace make { + type Constructor = Stringer; + const Constructor: typeof Stringer; + } + + function stringer(options?: StringerOptions): Stringer; + + namespace stringer { + type Constructor = Stringer; + const Constructor: typeof Stringer; + } +} diff --git a/types/stream-json/filters/Filter.d.ts b/types/stream-json/filters/Filter.d.ts new file mode 100644 index 0000000000..2a770925ca --- /dev/null +++ b/types/stream-json/filters/Filter.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as FilterBase from './FilterBase'; + +export = Filter; + +declare class Filter extends FilterBase { + constructor(options: FilterBase.FilterOptions); +} + +declare namespace Filter { + function make(options: FilterBase.FilterOptions): Filter; + + namespace make { + type Constructor = Filter; + const Constructor: typeof Filter; + } + + function filter(options: FilterBase.FilterOptions): Filter; + + namespace filter { + type Constructor = Filter; + const Constructor: typeof Filter; + } + + function withParser(options: FilterBase.FilterOptions): Chain; +} diff --git a/types/stream-json/filters/FilterBase.d.ts b/types/stream-json/filters/FilterBase.d.ts new file mode 100644 index 0000000000..43296561d4 --- /dev/null +++ b/types/stream-json/filters/FilterBase.d.ts @@ -0,0 +1,29 @@ +import { Transform, TransformOptions } from 'stream'; + +export = FilterBase; + +declare class FilterBase extends Transform { + constructor(options: FilterBase.FilterOptions); +} + +declare namespace FilterBase { + type Stack = ReadonlyArray; + + interface Token { + readonly name: string; + readonly value?: ReadonlyArray; + } + + type FilterFunction = (stack: Stack, token: Token) => boolean; + type ReplacementFunction = (stack: Stack, token: Token) => Token[]; + + interface FilterOptions extends TransformOptions { + filter: string | RegExp | FilterFunction; + once?: boolean; + pathSeparator?: string; + streamValues?: boolean; + streamKeys?: boolean; + replacement?: ReadonlyArray | ReplacementFunction; + allowEmptyReplacement?: boolean; + } +} diff --git a/types/stream-json/filters/Ignore.d.ts b/types/stream-json/filters/Ignore.d.ts new file mode 100644 index 0000000000..db805549d2 --- /dev/null +++ b/types/stream-json/filters/Ignore.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as FilterBase from './FilterBase'; + +export = Ignore; + +declare class Ignore extends FilterBase { + constructor(options: FilterBase.FilterOptions); +} + +declare namespace Ignore { + function make(options: FilterBase.FilterOptions): Ignore; + + namespace make { + type Constructor = Ignore; + const Constructor: typeof Ignore; + } + + function ignore(options: FilterBase.FilterOptions): Ignore; + + namespace ignore { + type Constructor = Ignore; + const Constructor: typeof Ignore; + } + + function withParser(options: FilterBase.FilterOptions): Chain; +} diff --git a/types/stream-json/filters/Pick.d.ts b/types/stream-json/filters/Pick.d.ts new file mode 100644 index 0000000000..f4504f20f5 --- /dev/null +++ b/types/stream-json/filters/Pick.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as FilterBase from './FilterBase'; + +export = Pick; + +declare class Pick extends FilterBase { + constructor(options: FilterBase.FilterOptions); +} + +declare namespace Pick { + function make(options: FilterBase.FilterOptions): Pick; + + namespace make { + type Constructor = Pick; + const Constructor: typeof Pick; + } + + function pick(options: FilterBase.FilterOptions): Pick; + + namespace pick { + type Constructor = Pick; + const Constructor: typeof Pick; + } + + function withParser(options: FilterBase.FilterOptions): Chain; +} diff --git a/types/stream-json/filters/Replace.d.ts b/types/stream-json/filters/Replace.d.ts new file mode 100644 index 0000000000..9f85b847f5 --- /dev/null +++ b/types/stream-json/filters/Replace.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as FilterBase from './FilterBase'; + +export = Replace; + +declare class Replace extends FilterBase { + constructor(options: FilterBase.FilterOptions); +} + +declare namespace Replace { + function make(options: FilterBase.FilterOptions): Replace; + + namespace make { + type Constructor = Replace; + const Constructor: typeof Replace; + } + + function replace(options: FilterBase.FilterOptions): Replace; + + namespace replace { + type Constructor = Replace; + const Constructor: typeof Replace; + } + + function withParser(options: FilterBase.FilterOptions): Chain; +} diff --git a/types/stream-json/index.d.ts b/types/stream-json/index.d.ts index 910cb17c17..9230408603 100644 --- a/types/stream-json/index.d.ts +++ b/types/stream-json/index.d.ts @@ -5,476 +5,33 @@ /// -declare module 'stream-json' { - import * as Parser from 'stream-json/Parser'; +import * as Assembler from './Assembler'; +import * as Emitter from './Emitter'; +import * as Parser from './Parser'; +import * as Stringer from './Stringer'; - export = make; +import * as FilterBase from './filters/FilterBase'; +import * as Pick from './filters/Pick'; +import * as Replace from './filters/Replace'; +import * as Ignore from './filters/Ignore'; +import * as Filter from './filters/Filter'; - function make(options?: Parser.ParserOptions): Parser; +import * as StreamArray from './streamers/StreamArray'; +import * as StreamObject from './streamers/StreamObject'; +import * as StreamValues from './streamers/StreamValues'; - type ParserClass = Parser; - type ParserType = typeof Parser; +import * as emit from './utils/emit'; +import * as withParser from './utils/withParser'; - namespace make { - type Parser = ParserClass; - const Parser: ParserType; - const parser: (options?: Parser.ParserOptions) => Parser; - } -} +export = make; -declare module 'stream-json/Assembler' { - import { EventEmitter } from 'events'; - import { Readable } from 'stream'; +declare function make(options?: Parser.ParserOptions): Parser; - export = Assembler; +type ParserClass = Parser; +type ParserType = typeof Parser; - type Token = { - name: string; - value?: string; - }; - - class Assembler extends EventEmitter { - constructor(); - - connectTo(stream: Readable): this; - consume(chunk: Token): this; - dropToLevel(level: number): this; - - current: any; - key: string | null; - stack: Array; - readonly done: boolean; - - readonly depth: number; - readonly path: string; - - // events - addListener(event: 'done', listener: (asm: Assembler) => void): this; - on(event: 'done', listener: (asm: Assembler) => void): this; - once(event: 'done', listener: (asm: Assembler) => void): this; - prependListener(event: 'done', listener: (asm: Assembler) => void): this; - prependOnceListener(event: 'done', listener: (asm: Assembler) => void): this; - removeListener(event: 'done', listener: (asm: Assembler) => void): this; - } - - namespace Assembler { - function connectTo(stream: Readable): Assembler; - } -} - -declare module 'stream-json/Emitter' { - import { Writable, WritableOptions } from 'stream'; - - export = Emitter; - - class Emitter extends Writable { - constructor(options?: WritableOptions); - } - - namespace Emitter { - function make(options?: WritableOptions): Emitter; - - namespace make { - type Constructor = Emitter; - const Constructor: typeof Emitter; - } - - function emitter(options?: WritableOptions): Emitter; - - namespace emitter { - type Constructor = Emitter; - const Constructor: typeof Emitter; - } - } -} - -declare module 'stream-json/Parser' { - import { Transform, TransformOptions } from 'stream'; - - export = Parser; - - class Parser extends Transform { - constructor(options?: Parser.ParserOptions); - } - - namespace Parser { - interface ParserOptions extends TransformOptions { - packValues?: boolean; - packKeys?: boolean; - packStrings?: boolean; - packNumbers?: boolean; - streamValues?: boolean; - streamKeys?: boolean; - streamStrings?: boolean; - streamNumbers?: boolean; - jsonStreaming?: boolean; - } - - function make(options?: ParserOptions): Parser; - - namespace make { - type Constructor = Parser; - const Constructor: typeof Parser; - } - - function parser(options?: ParserOptions): Parser; - - namespace parser { - type Constructor = Parser; - const Constructor: typeof Parser; - } - } -} - -declare module 'stream-json/Stringer' { - import { Transform, TransformOptions } from 'stream'; - - export = Stringer; - - class Stringer extends Transform { - constructor(options?: Stringer.StringerOptions); - } - - namespace Stringer { - interface StringerOptions extends TransformOptions { - useValues?: boolean; - useKeyValues?: boolean; - useStringValues?: boolean; - useNumberValues?: boolean; - } - - function make(options?: StringerOptions): Stringer; - - namespace make { - type Constructor = Stringer; - const Constructor: typeof Stringer; - } - - function stringer(options?: StringerOptions): Stringer; - - namespace stringer { - type Constructor = Stringer; - const Constructor: typeof Stringer; - } - } -} - -declare module 'stream-json/filters/FilterBase' { - import { Transform, TransformOptions } from 'stream'; - - export = FilterBase; - - class FilterBase extends Transform { - constructor(options: FilterBase.FilterOptions); - } - - namespace FilterBase { - type Stack = ReadonlyArray; - type Token = { readonly name: string; readonly value?: ReadonlyArray }; - - interface IFilterFunction { - (stack: Stack, token: Token): boolean; - } - - interface IReplacementFunction { - (stack: Stack, token: Token): Token[]; - } - - interface FilterOptions extends TransformOptions { - filter: string | RegExp | IFilterFunction; - once?: boolean; - pathSeparator?: string; - streamValues?: boolean; - streamKeys?: boolean; - replacement?: ReadonlyArray | IReplacementFunction; - allowEmptyReplacement?: boolean; - } - } -} - -declare module 'stream-json/filters/Pick' { - import * as Chain from 'stream-chain'; - import * as FilterBase from 'stream-json/filters/FilterBase'; - - export = Pick; - - class Pick extends FilterBase { - constructor(options: FilterBase.FilterOptions); - } - - namespace Pick { - function make(options: FilterBase.FilterOptions): Pick; - - namespace make { - type Constructor = Pick; - const Constructor: typeof Pick; - } - - function pick(options: FilterBase.FilterOptions): Pick; - - namespace pick { - type Constructor = Pick; - const Constructor: typeof Pick; - } - - function withParser(options: FilterBase.FilterOptions): Chain; - } -} - -declare module 'stream-json/filters/Replace' { - import * as Chain from 'stream-chain'; - import * as FilterBase from 'stream-json/filters/FilterBase'; - - export = Replace; - - class Replace extends FilterBase { - constructor(options: FilterBase.FilterOptions); - } - - namespace Replace { - function make(options: FilterBase.FilterOptions): Replace; - - namespace make { - type Constructor = Replace; - const Constructor: typeof Replace; - } - - function replace(options: FilterBase.FilterOptions): Replace; - - namespace replace { - type Constructor = Replace; - const Constructor: typeof Replace; - } - - function withParser(options: FilterBase.FilterOptions): Chain; - } -} - -declare module 'stream-json/filters/Ignore' { - import * as Chain from 'stream-chain'; - import * as FilterBase from 'stream-json/filters/FilterBase'; - - export = Ignore; - - class Ignore extends FilterBase { - constructor(options: FilterBase.FilterOptions); - } - - namespace Ignore { - function make(options: FilterBase.FilterOptions): Ignore; - - namespace make { - type Constructor = Ignore; - const Constructor: typeof Ignore; - } - - function ignore(options: FilterBase.FilterOptions): Ignore; - - namespace ignore { - type Constructor = Ignore; - const Constructor: typeof Ignore; - } - - function withParser(options: FilterBase.FilterOptions): Chain; - } -} - -declare module 'stream-json/filters/Filter' { - import * as Chain from 'stream-chain'; - import * as FilterBase from 'stream-json/filters/FilterBase'; - - export = Filter; - - class Filter extends FilterBase { - constructor(options: FilterBase.FilterOptions); - } - - namespace Filter { - function make(options: FilterBase.FilterOptions): Filter; - - namespace make { - type Constructor = Filter; - const Constructor: typeof Filter; - } - - function filter(options: FilterBase.FilterOptions): Filter; - - namespace filter { - type Constructor = Filter; - const Constructor: typeof Filter; - } - - function withParser(options: FilterBase.FilterOptions): Chain; - } -} - -declare module 'stream-json/streamers/StreamBase' { - import { Transform, TransformOptions } from 'stream'; - import * as Assembler from 'stream-json/Assembler'; - - export = StreamBase; - - class StreamBase extends Transform { - constructor(options?: StreamBase.StreamOptions); - } - - namespace StreamBase { - interface IObjectFilterFunction { - (asm: Readonly): boolean | undefined; - } - - interface StreamOptions extends TransformOptions { - objectFilter?: IObjectFilterFunction; - includeUndecided?: boolean; - } - } -} - -declare module 'stream-json/streamers/StreamArray' { - import * as Chain from 'stream-chain'; - import * as StreamBase from 'stream-json/streamers/StreamBase'; - - export = StreamArray; - - class StreamArray extends StreamBase { - constructor(options?: StreamBase.StreamOptions); - } - - namespace StreamArray { - function make(options?: StreamBase.StreamOptions): StreamArray; - - namespace make { - type Constructor = StreamArray; - const Constructor: typeof StreamArray; - } - - function streamArray(options?: StreamBase.StreamOptions): StreamArray; - - namespace streamArray { - type Constructor = StreamArray; - const Constructor: typeof StreamArray; - } - - function withParser(options?: StreamBase.StreamOptions): Chain; - } -} - -declare module 'stream-json/streamers/StreamObject' { - import * as Chain from 'stream-chain'; - import * as StreamBase from 'stream-json/streamers/StreamBase'; - - export = StreamObject; - - class StreamObject extends StreamBase { - constructor(options?: StreamBase.StreamOptions); - } - - namespace StreamObject { - function make(options?: StreamBase.StreamOptions): StreamObject; - - namespace make { - type Constructor = StreamObject; - const Constructor: typeof StreamObject; - } - - function streamObject(options?: StreamBase.StreamOptions): StreamObject; - - namespace streamObject { - type Constructor = StreamObject; - const Constructor: typeof StreamObject; - } - - function withParser(options?: StreamBase.StreamOptions): Chain; - } -} - -declare module 'stream-json/streamers/StreamValues' { - import * as Chain from 'stream-chain'; - import * as StreamBase from 'stream-json/streamers/StreamBase'; - - export = StreamValues; - - class StreamValues extends StreamBase { - constructor(options?: StreamBase.StreamOptions); - } - - namespace StreamValues { - function make(options?: StreamBase.StreamOptions): StreamValues; - - namespace make { - type Constructor = StreamValues; - const Constructor: typeof StreamValues; - } - - function streamValues(options?: StreamBase.StreamOptions): StreamValues; - - namespace streamValues { - type Constructor = StreamValues; - const Constructor: typeof StreamValues; - } - - function withParser(options?: StreamBase.StreamOptions): Chain; - } -} - -declare module 'stream-json/utils/emit' { - import { Writable, Duplex, Transform } from 'stream'; - - export = emit; - - function emit(stream: Stream): Stream; - - namespace emit { - - } -} - -declare module 'stream-json/utils/withParser' { - import { Writable, WritableOptions, Duplex, DuplexOptions, Transform, TransformOptions } from 'stream'; - import * as Chain from 'stream-chain'; - import * as Parser from 'stream-json/Parser'; - import * as FilterBase from 'stream-json/filters/FilterBase'; - import * as StreamBase from 'stream-json/streamers/StreamBase'; - - export = withParser; - - function withParser( - fn: (options: FilterBase.FilterOptions) => Stream, - options?: withParser.FilterOptions - ): Chain; - - function withParser( - fn: (options?: StreamBase.StreamOptions) => Stream, - options?: withParser.StreamOptions - ): Chain; - - function withParser(fn: (options?: TransformOptions) => Transform, options?: Parser.ParserOptions): Chain; - - namespace withParser { - interface FilterOptions extends FilterBase.FilterOptions { - // copied from ParserOptions - packValues?: boolean; - packKeys?: boolean; - packStrings?: boolean; - packNumbers?: boolean; - streamValues?: boolean; - streamKeys?: boolean; - streamStrings?: boolean; - streamNumbers?: boolean; - jsonStreaming?: boolean; - } - - interface StreamOptions extends StreamBase.StreamOptions { - // copied from ParserOptions - packValues?: boolean; - packKeys?: boolean; - packStrings?: boolean; - packNumbers?: boolean; - streamValues?: boolean; - streamKeys?: boolean; - streamStrings?: boolean; - streamNumbers?: boolean; - jsonStreaming?: boolean; - } - } +declare namespace make { + type Parser = ParserClass; + const Parser: ParserType; + function parser(options?: Parser.ParserOptions): Parser; } diff --git a/types/stream-json/stream-json-tests.ts b/types/stream-json/stream-json-tests.ts index 587e01d6ae..76e21071f1 100644 --- a/types/stream-json/stream-json-tests.ts +++ b/types/stream-json/stream-json-tests.ts @@ -52,7 +52,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.on('keyValue', (value: string) => console.log(value, asm.key, asm.stack.length, asm.done, asm.depth, asm.path) ); - asm.on('done', asm => console.log(JSON.stringify(asm.current))); + asm.on('done', (asm: Assembler) => console.log(JSON.stringify(asm.current))); } { @@ -205,7 +205,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( new StreamArray({ includeUndecided: true, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; @@ -216,7 +216,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( StreamArray.make({ includeUndecided: false, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; @@ -245,7 +245,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( new StreamObject({ includeUndecided: true, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; @@ -256,7 +256,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( StreamObject.make({ includeUndecided: false, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; @@ -285,7 +285,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( new StreamValues({ includeUndecided: true, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; @@ -296,7 +296,7 @@ const used = (array: any[]) => array.forEach(value => console.log(!!value)); parser.pipe( StreamValues.make({ includeUndecided: false, - objectFilter: (asm: Readonly) => { + objectFilter: (asm: Assembler) => { if (asm.current) { if (asm.current.action === 'accept') return true; if (asm.current.action === 'reject') return false; diff --git a/types/stream-json/streamers/StreamArray.d.ts b/types/stream-json/streamers/StreamArray.d.ts new file mode 100644 index 0000000000..4961e95bf8 --- /dev/null +++ b/types/stream-json/streamers/StreamArray.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as StreamBase from './StreamBase'; + +export = StreamArray; + +declare class StreamArray extends StreamBase { + constructor(options?: StreamBase.StreamOptions); +} + +declare namespace StreamArray { + function make(options?: StreamBase.StreamOptions): StreamArray; + + namespace make { + type Constructor = StreamArray; + const Constructor: typeof StreamArray; + } + + function streamArray(options?: StreamBase.StreamOptions): StreamArray; + + namespace streamArray { + type Constructor = StreamArray; + const Constructor: typeof StreamArray; + } + + function withParser(options?: StreamBase.StreamOptions): Chain; +} diff --git a/types/stream-json/streamers/StreamBase.d.ts b/types/stream-json/streamers/StreamBase.d.ts new file mode 100644 index 0000000000..641694efc4 --- /dev/null +++ b/types/stream-json/streamers/StreamBase.d.ts @@ -0,0 +1,17 @@ +import { Transform, TransformOptions } from 'stream'; +import * as Assembler from '../Assembler'; + +export = StreamBase; + +declare class StreamBase extends Transform { + constructor(options?: StreamBase.StreamOptions); +} + +declare namespace StreamBase { + type ObjectFilterFunction = (asm: Assembler) => boolean | undefined; + + interface StreamOptions extends TransformOptions { + objectFilter?: ObjectFilterFunction; + includeUndecided?: boolean; + } +} diff --git a/types/stream-json/streamers/StreamObject.d.ts b/types/stream-json/streamers/StreamObject.d.ts new file mode 100644 index 0000000000..efaeed75ad --- /dev/null +++ b/types/stream-json/streamers/StreamObject.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as StreamBase from './StreamBase'; + +export = StreamObject; + +declare class StreamObject extends StreamBase { + constructor(options?: StreamBase.StreamOptions); +} + +declare namespace StreamObject { + function make(options?: StreamBase.StreamOptions): StreamObject; + + namespace make { + type Constructor = StreamObject; + const Constructor: typeof StreamObject; + } + + function streamObject(options?: StreamBase.StreamOptions): StreamObject; + + namespace streamObject { + type Constructor = StreamObject; + const Constructor: typeof StreamObject; + } + + function withParser(options?: StreamBase.StreamOptions): Chain; +} diff --git a/types/stream-json/streamers/StreamValues.d.ts b/types/stream-json/streamers/StreamValues.d.ts new file mode 100644 index 0000000000..2ffe1a0719 --- /dev/null +++ b/types/stream-json/streamers/StreamValues.d.ts @@ -0,0 +1,26 @@ +import * as Chain from 'stream-chain'; +import * as StreamBase from './StreamBase'; + +export = StreamValues; + +declare class StreamValues extends StreamBase { + constructor(options?: StreamBase.StreamOptions); +} + +declare namespace StreamValues { + function make(options?: StreamBase.StreamOptions): StreamValues; + + namespace make { + type Constructor = StreamValues; + const Constructor: typeof StreamValues; + } + + function streamValues(options?: StreamBase.StreamOptions): StreamValues; + + namespace streamValues { + type Constructor = StreamValues; + const Constructor: typeof StreamValues; + } + + function withParser(options?: StreamBase.StreamOptions): Chain; +} diff --git a/types/stream-json/tsconfig.json b/types/stream-json/tsconfig.json index 37ea09ac3f..7bc52c45ec 100644 --- a/types/stream-json/tsconfig.json +++ b/types/stream-json/tsconfig.json @@ -9,7 +9,8 @@ "typeRoots": ["../"], "types": [], "noEmit": true, - "forceConsistentCasingInFileNames": true + "forceConsistentCasingInFileNames": true, + "strictFunctionTypes": true }, "files": ["index.d.ts", "stream-json-tests.ts"] } diff --git a/types/stream-json/utils/emit.d.ts b/types/stream-json/utils/emit.d.ts new file mode 100644 index 0000000000..82b32f153c --- /dev/null +++ b/types/stream-json/utils/emit.d.ts @@ -0,0 +1,7 @@ +import { Writable, Duplex, Transform } from 'stream'; + +export = emit; + +declare function emit(stream: Stream): Stream; + +declare namespace emit {} diff --git a/types/stream-json/utils/withParser.d.ts b/types/stream-json/utils/withParser.d.ts new file mode 100644 index 0000000000..ef509366df --- /dev/null +++ b/types/stream-json/utils/withParser.d.ts @@ -0,0 +1,47 @@ +import { Writable, WritableOptions, Duplex, DuplexOptions, Transform, TransformOptions } from 'stream'; +import * as Chain from 'stream-chain'; +import * as Parser from '../Parser'; +import * as FilterBase from '../filters/FilterBase'; +import * as StreamBase from '../streamers/StreamBase'; + +export = withParser; + +declare function withParser( + fn: (options: FilterBase.FilterOptions) => FilterBase, + options?: withParser.FilterOptions +): Chain; + +declare function withParser( + fn: (options?: StreamBase.StreamOptions) => StreamBase, + options?: withParser.StreamOptions +): Chain; + +declare function withParser(fn: (options?: TransformOptions) => Transform, options?: Parser.ParserOptions): Chain; + +declare namespace withParser { + interface FilterOptions extends FilterBase.FilterOptions { + // copied from ParserOptions + packValues?: boolean; + packKeys?: boolean; + packStrings?: boolean; + packNumbers?: boolean; + streamValues?: boolean; + streamKeys?: boolean; + streamStrings?: boolean; + streamNumbers?: boolean; + jsonStreaming?: boolean; + } + + interface StreamOptions extends StreamBase.StreamOptions { + // copied from ParserOptions + packValues?: boolean; + packKeys?: boolean; + packStrings?: boolean; + packNumbers?: boolean; + streamValues?: boolean; + streamKeys?: boolean; + streamStrings?: boolean; + streamNumbers?: boolean; + jsonStreaming?: boolean; + } +}