From b47a73595c29bde94f0e909ae9d7f3c23ed36b0a Mon Sep 17 00:00:00 2001 From: Paul Douglas Brimicombe Date: Fri, 7 Jul 2017 20:09:06 +0100 Subject: [PATCH] Update type definitions for random-js --- types/random-js/index.d.ts | 121 +++++++++++++++-------------- types/random-js/random-js-tests.ts | 119 ++++++++++++++++++++++++++-- types/random-js/tslint.json | 4 + 3 files changed, 176 insertions(+), 68 deletions(-) create mode 100644 types/random-js/tslint.json diff --git a/types/random-js/index.d.ts b/types/random-js/index.d.ts index fd3909e508..6f03ffbd40 100644 --- a/types/random-js/index.d.ts +++ b/types/random-js/index.d.ts @@ -1,69 +1,70 @@ -// Type definitions for random-js 1.0.8 +// Type definitions for random-js 1.0 // Project: https://github.com/ckknight/random-js // Definitions by: Gustavo Di Pietro // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +declare namespace Random { + interface Engine { + (): number; // tslint:disable-line callable-types + } -declare module TemporaryName { - - export interface Engine { - - } - - export interface MT19937 extends Engine{ - seed (value: number): Engine; - seedWithArray(array: Array): Engine - autoSeed(): Engine; - discard(count: number): Engine; - getUseCount(): Engine; - } - + interface MT19937 extends Engine { + seed(value: number): MT19937; + seedWithArray(array: number[]): MT19937; + autoSeed(): MT19937; + discard(count: number): MT19937; + getUseCount(): number; + } } -declare class TemporaryName { - constructor (engine?: TemporaryName.Engine); - - static engines: { - nativeMath: TemporaryName.Engine, - browserCrypto: TemporaryName.Engine, - mt19937: () => TemporaryName.MT19937 - } - - static Engine(): number; - static MT19937 (): number; - - static integer(min: number, max: number): (engine: TemporaryName.Engine) => number; - static real(min: number, max: number, inclusive: boolean): (engine: TemporaryName.Engine) => number; - static bool(percentage?: number): (engine: TemporaryName.Engine) => boolean; - static bool(numerator: number, denominator: number): (engine: TemporaryName.Engine) => boolean; - static pick(engine: TemporaryName.Engine, array: Array, begin?: number, end?: number): T; - static picker(array: Array, begin?: number, end?: number): (engine: TemporaryName.Engine) => T; - static shuffle(engine: TemporaryName.Engine, array: Array): Array; - static sample(engine: TemporaryName.Engine, population: Array, sampleSize: number): Array; - static die(sideCount: number): (engine: TemporaryName.Engine) => number; - static dice(sideCount: number, dieCount: number): (engine: TemporaryName.Engine) => number; - static uuid4(engine: TemporaryName.Engine): string; - static string(engine: TemporaryName.Engine, length: number): string; - static string(pool: string, length: number): (engine: TemporaryName.Engine, length: number) => string; - static hex(upperCase?: boolean): (engine: TemporaryName.Engine, length: number) => string; - static date(start: Date, end: Date): (engine: TemporaryName.Engine) => Date; - - integer(min: number, max: number): number; - real(min: number, max: number, inclusive: boolean): number; - bool(percentage?: number): (engine: TemporaryName.Engine) => boolean; - bool(numerator: number, denominator: number): boolean; - pick(engine: TemporaryName.Engine, array: Array, begin?: number, end?: number): T; - picker(array: Array, begin?: number, end?: number): (engine: TemporaryName.Engine) => T; - shuffle(engine: TemporaryName.Engine, array: Array): Array; - sample(engine: TemporaryName.Engine, population: Array, sampleSize: number): Array; - die(sideCount: number): (engine: TemporaryName.Engine) => number; - dice(sideCount: number, dieCount: number): number; - uuid4(engine: TemporaryName.Engine): string; - string(engine: TemporaryName.Engine, length: number): string; - string(pool: string, length: number): string; - hex(upperCase?: boolean): string; - date(start: Date, end: Date): Date; +interface Random { + integer(min: number, max: number): number; + real(min: number, max: number, inclusive?: boolean): number; + bool(percentage?: number): boolean; // tslint:disable-line unified-signatures + bool(numerator: number, denominator: number): boolean; // tslint:disable-line unified-signatures + pick(array: T[], begin?: number, end?: number): T; + shuffle(array: T[]): T[]; + sample(population: T[], sampleSize: number): T[]; + die(sideCount: number): number; + dice(sideCount: number, dieCount: number): number[]; + uuid4(engine: Random.Engine): string; + string(engine: Random.Engine, length: number): string; + string(length?: number, pool?: string): string; + hex(length?: number, upperCase?: boolean): string; + date(start: Date, end: Date): Date; } -export = TemporaryName; -export as namespace Random; \ No newline at end of file +interface RandomConstructor { + (engine?: Engine): Random; + new (engine?: Engine): Random; + + engines: { + nativeMath: Random.Engine, + browserCrypto: Random.Engine, + mt19937(): Random.MT19937 + }; + + Engine(): number; + MT19937(): number; + + integer(min: number, max: number): (engine: Random.Engine) => number; + real(min: number, max: number, inclusive?: boolean): (engine: Random.Engine) => number; + bool(percentage?: number): (engine: Random.Engine) => boolean; // tslint:disable-line unified-signatures + bool(numerator: number, denominator: number): (engine: Random.Engine) => boolean; // tslint:disable-line unified-signatures + pick(engine: Random.Engine, array: T[], begin?: number, end?: number): T; + picker(array: T[], begin?: number, end?: number): (engine: Random.Engine) => T; + shuffle(engine: Random.Engine, array: T[]): T[]; + sample(engine: Random.Engine, population: T[], sampleSize: number): T[]; + die(sideCount: number): (engine: Random.Engine) => number; + dice(sideCount: number, dieCount: number): (engine: Random.Engine) => number[]; + uuid4(engine: Random.Engine): string; + string(engine: Random.Engine, length: number): string; + string(pool?: string): (engine: Random.Engine, length?: number) => string; + hex(upperCase?: boolean): (engine: Random.Engine, length?: number) => string; + date(start: Date, end: Date): (engine: Random.Engine) => Date; +} + +declare const Random: RandomConstructor; + +export = Random; +export as namespace Random; diff --git a/types/random-js/random-js-tests.ts b/types/random-js/random-js-tests.ts index 1b9e27c177..ef438e18c5 100644 --- a/types/random-js/random-js-tests.ts +++ b/types/random-js/random-js-tests.ts @@ -1,25 +1,128 @@ +import Engine = Random.Engine; +import MersenneTwisterEngine = Random.MT19937; + +class CustomType {} +const customTypeArray = [new CustomType(), new CustomType(), new CustomType()]; + +// APIs taken from the documentation at https://github.com/ckknight/random-js + +// Basic engine types (https://github.com/ckknight/random-js#engines) +let engine: Engine = Random.engines.nativeMath; +engine = Random.engines.browserCrypto; + +// All engines can be used to generate numbers +let generated: number = engine(); + +// Mersenne Twister API (https://github.com/ckknight/random-js#mersenne-twister-api) +let mersenneTwister: MersenneTwisterEngine = Random.engines.mt19937(); +generated = mersenneTwister(); + +mersenneTwister = mersenneTwister.seed(0x9a0b1d43); +mersenneTwister = mersenneTwister.seedWithArray([0x12345678, 0x90abcdef]); +mersenneTwister = mersenneTwister.autoSeed(); +mersenneTwister = mersenneTwister.discard(10); +const useCount: number = mersenneTwister.getUseCount(); + +// Static "Distributions" API (https://github.com/ckknight/random-js#distributions) +let numeric: number = Random.integer(0, 99)(engine); +numeric = Random.real(0, 10)(engine); +numeric = Random.real(0, 10, true)(engine); + +let bool: boolean = Random.bool()(engine); +bool = Random.bool(20)(engine); +bool = Random.bool(1, 2)(engine); + +let chosen: CustomType = Random.pick(engine, customTypeArray); +chosen = Random.pick(engine, customTypeArray, 0); +chosen = Random.pick(engine, customTypeArray, 0, 2); +chosen = Random.picker(customTypeArray); +chosen = Random.picker(customTypeArray, 0); +chosen = Random.picker(customTypeArray, 0, 2); + +let shuffled: CustomType[] = Random.shuffle(engine, customTypeArray); +let sampled: CustomType[] = Random.sample(engine, customTypeArray, 2); + +numeric = Random.die(5)(engine); +let dieValues: number[] = Random.dice(5, 2)(engine); + +let uuid: string = Random.uuid4(engine); + +let str: string = Random.string()(engine); +str = Random.string()(engine); +str = Random.string()(engine, 10); +str = Random.string('abc')(engine); +str = Random.string('abc')(engine, 2); + +let hex: string = Random.hex()(engine); +hex = Random.hex()(engine, 5); +hex = Random.hex(false)(engine); +hex = Random.hex(false)(engine, 5); +hex = Random.hex(true)(engine); +hex = Random.hex(true)(engine, 5); + +let date: Date = Random.date(new Date(), new Date())(engine); + +// "Alternate" API (https://github.com/ckknight/random-js#alternate-api) + +let random: Random = new Random(engine); +random = new Random(); +random = Random(); + +numeric = random.integer(0, 99); +numeric = random.real(0, 10); +numeric = random.real(0, 10, true); + +bool = random.bool(); +bool = random.bool(50); +bool = random.bool(1, 2); + +chosen = random.pick(customTypeArray); +chosen = random.pick(customTypeArray, 0); +chosen = random.pick(customTypeArray, 0, 2); + +shuffled = random.shuffle(customTypeArray); +sampled = random.sample(customTypeArray, 2); + +numeric = random.die(5); +dieValues = random.dice(5, 2); + +uuid = Random.uuid4(engine); + +str = random.string(); +str = random.string(10); +str = random.string(10, 'abc'); + +hex = random.hex(); +hex = random.hex(5); +hex = random.hex(5, false); +hex = random.hex(undefined, false); +hex = random.hex(5, true); +hex = random.hex(undefined, true); + +date = random.date(new Date(), new Date()); + // Examples taken from the documentation at https://github.com/ckknight/random-js // create a Mersenne Twister-19937 that is auto-seeded based on time and other random values -import Engine = Random.Engine; -var engine: Engine = Random.engines.mt19937().autoSeed(); +engine = Random.engines.mt19937().autoSeed(); // create a distribution that will consistently produce integers within inclusive range [0, 99]. -var distribution: Function = Random.integer(0, 99); +const distribution: ((engine: Engine) => number) = Random.integer(0, 99); // generate a number that is guaranteed to be within [0, 99] without any particular bias. function generateNaturalLessThan100(): number { return distribution(engine); } +// NOTE: The documentation for this example is incorrect in the library documentation // using essentially Math.random() -var engine2: Engine = Random.engines.nativeMath; +const engine2: Engine = Random.engines.nativeMath; // lower-case Hex string distribution -var distribution2: Function = Random.hex(false); +const distribution2: ((engine: Engine, length: number) => string) = Random.hex(false); // generate a 40-character hex string function generateSHA1(): string { - return distribution(40); + return distribution2(engine2, 40); } -var r: Random = new Random(Random.engines.mt19937().seedWithArray([0x12345678, 0x90abcdef])); -var value = r.integer(0, 99); +let r: Random = new Random(Random.engines.mt19937().seedWithArray([0x12345678, 0x90abcdef])); +const value = r.integer(0, 99); r = new Random(); // same as new Random(Random.engines.nativeMath) diff --git a/types/random-js/tslint.json b/types/random-js/tslint.json new file mode 100644 index 0000000000..e26ec8f7eb --- /dev/null +++ b/types/random-js/tslint.json @@ -0,0 +1,4 @@ +{ + "extends": "dtslint/dt.json", + "rules": {} +}