vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-10-04 23:07:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #17852 from paulbrimicombe/master

Browse Source 
Update type definitions for random-js
This commit is contained in:
Ryan Cavanaugh
2017-07-13 12:56:41 -07:00
committed by GitHub
parent 7c37ce00e1 b47a73595c
commit d003dbcd88
3 changed files with 176 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/random-js/index.d.ts
Vendored
+61 -60
View File
@@ -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 <https://github.com/pistacchio>
// 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<number>): 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<T>(engine: TemporaryName.Engine, array: Array<T>, begin?: number, end?: number): T;
static picker<T>(array: Array<T>, begin?: number, end?: number): (engine: TemporaryName.Engine) => T;
static shuffle<T>(engine: TemporaryName.Engine, array: Array<T>): Array<T>;
static sample<T>(engine: TemporaryName.Engine, population: Array<T>, sampleSize: number): Array<T>;
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<T>(engine: TemporaryName.Engine, array: Array<T>, begin?: number, end?: number): T;
picker<T>(array: Array<T>, begin?: number, end?: number): (engine: TemporaryName.Engine) => T;
shuffle<T>(engine: TemporaryName.Engine, array: Array<T>): Array<T>;
sample<T>(engine: TemporaryName.Engine, population: Array<T>, sampleSize: number): Array<T>;
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<T>(array: T[], begin?: number, end?: number): T;
shuffle<T>(array: T[]): T[];
sample<T>(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;
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<T>(engine: Random.Engine, array: T[], begin?: number, end?: number): T;
picker<T>(array: T[], begin?: number, end?: number): (engine: Random.Engine) => T;
shuffle<T>(engine: Random.Engine, array: T[]): T[];
sample<T>(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;
types/random-js/random-js-tests.ts
+111 -8
View File
@@ -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)
types/random-js/tslint.json
+4
View File
@@ -0,0 +1,4 @@
{
"extends": "dtslint/dt.json",
"rules": {}
}