Merge pull request DefinitelyTyped#28514 from danwbyrne/bitwise

adds typings for the 'bitwise' package

types/bitwise/bits/and.d.ts

@@ -0,0 +1,4 @@
+export default function and(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/index.d.ts

@@ -0,0 +1,33 @@
+import bitsAnd from './and';
+import bitsNor from './nor';
+import bitsNot from './not';
+import bitsOr from './or';
+import bitsReduceAnd from './reduce-and';
+import bitsReduceNand from './reduce-nand';
+import bitsReduceNor from './reduce-nor';
+import bitsReduceOr from './reduce-or';
+import bitsReduceXnor from './reduce-xnor';
+import bitsReduceXor from './reduce-xor';
+import bitsToBoolean from './to-boolean';
+import bitsToString from './to-string';
+import bitsXnor from './xnor';
+import bitsXor from './xor';
+
+declare namespace bits {
+  const and: typeof bitsAnd;
+  const nor: typeof bitsNor;
+  const not: typeof bitsNot;
+  const or: typeof bitsOr;
+  const reduceAnd: typeof bitsReduceAnd;
+  const reduceNand: typeof bitsReduceNand;
+  const reduceNor: typeof bitsReduceNor;
+  const reduceOr: typeof bitsReduceOr;
+  const reduceXnor: typeof bitsReduceXnor;
+  const reduceXor: typeof bitsReduceXor;
+  const toBoolean: typeof bitsToBoolean;
+  const toString: typeof bitsToString;
+  const xnor: typeof bitsXnor;
+  const xor: typeof bitsXor;
+}
+
+export default bits;

types/bitwise/bits/nand.d.ts

@@ -0,0 +1,4 @@
+export default function nand(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/nor.d.ts

@@ -0,0 +1,4 @@
+export default function nor(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/not.d.ts

@@ -0,0 +1,4 @@
+export default function not(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/or.d.ts

@@ -0,0 +1,4 @@
+export default function or(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/reduce-and.d.ts

@@ -0,0 +1 @@
+export default function reduceAnd(bits: ReadonlyArray<number>): number;

types/bitwise/bits/reduce-nand.d.ts

@@ -0,0 +1 @@
+export default function reduceNand(bits: ReadonlyArray<number>): number;

types/bitwise/bits/reduce-nor.d.ts

@@ -0,0 +1 @@
+export default function reduceNor(bits: ReadonlyArray<number>): number;

types/bitwise/bits/reduce-or.d.ts

@@ -0,0 +1 @@
+export default function reduceOr(bits: ReadonlyArray<number>): number;

types/bitwise/bits/reduce-xnor.d.ts

@@ -0,0 +1 @@
+export default function reduceXnor(bits: ReadonlyArray<number>): number;

types/bitwise/bits/reduce-xor.d.ts

@@ -0,0 +1 @@
+export default function reduceXor(bits: ReadonlyArray<number>): number;

types/bitwise/bits/to-boolean.d.ts

@@ -0,0 +1,3 @@
+export default function toBoolean(
+  bits: ReadonlyArray<number>
+): ReadonlyArray<boolean>;

types/bitwise/bits/to-string.d.ts

@@ -0,0 +1,5 @@
+export default function toString(
+  bit: ReadonlyArray<number>,
+  spacing?: number,
+  spacer?: string
+): string;

types/bitwise/bits/xnor.d.ts

@@ -0,0 +1,4 @@
+export default function xnor(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bits/xor.d.ts

@@ -0,0 +1,4 @@
+export default function xor(
+  bits1: ReadonlyArray<number>,
+  bits2: ReadonlyArray<number>
+): ReadonlyArray<number>;

types/bitwise/bitwise-tests.ts

@@ -0,0 +1,56 @@
+// Demonstrating cherry-picking
+import bitwise from 'bitwise';
+
+import bits from 'bitwise/bits';
+import toBoolean from 'bitwise/bits/to-boolean';
+
+import buffer from 'bitwise/buffer';
+import create from 'bitwise/buffer/create';
+
+import byte from 'bitwise/byte';
+import read from 'bitwise/byte/read';
+
+import integer from 'bitwise/integer';
+import setBit from 'bitwise/integer/set-bit';
+
+import nibble from 'bitwise/nibble';
+import nibbleRead from 'bitwise/nibble/read';
+
+import string from 'bitwise/string';
+import toBits from 'bitwise/string/to-bits';
+
+// Testing basic functions
+const testBits = [0, 1, 1, 0, 1];
+
+// $ExpectType string
+bitwise.bits.toString(testBits);
+
+// $ExpectType ReadonlyArray<boolean>
+bits.toBoolean(testBits);
+// $ExpectType ReadonlyArray<boolean>
+toBoolean(testBits);
+
+// $ExpectType ReadonlyArray<number>
+byte.read(12);
+// $ExpectType ReadonlyArray<number>
+read(12);
+
+// $ExpectType Buffer
+buffer.create(testBits);
+// $ExpectType Buffer
+create(testBits);
+
+// $ExpectType ReadonlyArray<number>
+integer.setBit(12, 1, 0);
+// $ExpectType ReadonlyArray<number>
+setBit(12, 1, 0);
+
+// $ExpectType ReadonlyArray<number>
+nibble.read(15);
+// $ExpectType ReadonlyArray<number>
+nibbleRead(15);
+
+// $ExpectType ReadonlyArray<number>
+string.toBits('10 10 12$%_.0');
+// $ExpectType ReadonlyArray<number>
+toBits('10 10 12$%_.0');

types/bitwise/buffer/and.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function and(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping?: boolean
+): Buffer;

types/bitwise/buffer/create.d.ts

@@ -0,0 +1,3 @@
+/// <reference types= "node" />
+
+export default function create(bits: ReadonlyArray<number>): Buffer;

types/bitwise/buffer/index.d.ts

@@ -0,0 +1,31 @@
+import bufferAnd from './and';
+import bufferCreate from './create';
+import bufferModify from './modify';
+import bufferNand from './nand';
+import bufferNor from './nor';
+import bufferNot from './not';
+import bufferOr from './or';
+import bufferRead from './read';
+import bufferReadCInt from './read-c-int';
+import bufferReadInt from './read-int';
+import bufferReadUInt from './read-u-int';
+import bufferXnor from './xnor';
+import bufferXor from './xor';
+
+declare namespace buffer {
+  const and: typeof bufferAnd;
+  const create: typeof bufferCreate;
+  const modify: typeof bufferModify;
+  const nand: typeof bufferNand;
+  const nor: typeof bufferNor;
+  const not: typeof bufferNot;
+  const or: typeof bufferOr;
+  const read: typeof bufferRead;
+  const readCInt: typeof bufferReadCInt;
+  const readInt: typeof bufferReadInt;
+  const readUInt: typeof bufferReadUInt;
+  const xnor: typeof bufferXnor;
+  const xor: typeof bufferXor;
+}
+
+export default buffer;

types/bitwise/buffer/modify.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function modify(
+  buffer: Buffer,
+  newBits: ReadonlyArray<number>,
+  bitOffset?: number
+): void;

types/bitwise/buffer/nand.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function nand(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping?: boolean
+): Buffer;

types/bitwise/buffer/nor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function nor(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping: boolean
+): Buffer;

types/bitwise/buffer/not.d.ts

@@ -0,0 +1,3 @@
+/// <reference types= "node" />
+
+export default function not(buffer: Buffer): Buffer;

types/bitwise/buffer/or.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function or(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping?: boolean
+): Buffer;

types/bitwise/buffer/read-c-int.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function readCInt(
+  buffer: Buffer,
+  bitOffset?: number,
+  bitLength?: number
+): number;

types/bitwise/buffer/read-int.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function readInt(
+  buffer: Buffer,
+  bitOffset?: number,
+  bitLength?: number
+): number;

types/bitwise/buffer/read-u-int.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function readUInt(
+  buffer: Buffer,
+  bitOffset?: number,
+  bitLength?: number
+): number;

types/bitwise/buffer/read.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function read(
+	buffer: Buffer,
+	bitOffset?: number,
+	bitLength?: number
+): ReadonlyArray<number>;

types/bitwise/buffer/xnor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function xnor(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping?: boolean
+): Buffer;

types/bitwise/buffer/xor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types= "node" />
+
+export default function xor(
+  buffer1: Buffer,
+  buffer2: Buffer,
+  isLooping?: boolean
+): Buffer;

types/bitwise/byte/index.d.ts

@@ -0,0 +1,9 @@
+import byteRead from './read';
+import byteWrite from './write';
+
+declare namespace byte {
+  const read: typeof byteRead;
+  const write: typeof byteWrite;
+}
+
+export default byte;

types/bitwise/byte/read.d.ts

@@ -0,0 +1 @@
+export default function read(byte: number): ReadonlyArray<number>;

types/bitwise/byte/write.d.ts

@@ -0,0 +1 @@
+export default function write(bits: ReadonlyArray<number>): number;

types/bitwise/index.d.ts

@@ -0,0 +1,22 @@
+// Type definitions for bitwise 1.5
+// Project: https://github.com/dodekeract/bitwise
+// Definitions by: Daniel Byrne <https://github.com/danwbyrne>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import bitwiseBits from './bits';
+import bitwiseBuffer from './buffer';
+import bitwiseByte from './byte';
+import bitwiseInteger from './integer';
+import bitwiseNibble from './nibble';
+import bitwiseString from './string';
+
+declare namespace bitwise {
+  const bits: typeof bitwiseBits;
+  const buffer: typeof bitwiseBuffer;
+  const byte: typeof bitwiseByte;
+  const integer: typeof bitwiseInteger;
+  const nibble: typeof bitwiseNibble;
+  const string: typeof bitwiseString;
+}
+
+export default bitwise;

types/bitwise/integer/get-bit.d.ts

@@ -0,0 +1 @@
+export default function getBit(number: number, position: number): number;

types/bitwise/integer/index.d.ts

@@ -0,0 +1,11 @@
+import integerGetBit from './get-bit';
+import integerSetBit from './set-bit';
+import integerToggleBit from './toggle-bit';
+
+declare namespace integer {
+  const getBit: typeof integerGetBit;
+  const setBit: typeof integerSetBit;
+  const toggleBit: typeof integerToggleBit;
+}
+
+export default integer;

types/bitwise/integer/set-bit.d.ts

@@ -0,0 +1,5 @@
+export default function setBit(
+  number: number,
+  position: number,
+  value: number
+): ReadonlyArray<number>;

types/bitwise/integer/toggle-bit.d.ts

@@ -0,0 +1,4 @@
+export default function toggleBit(
+  number: number,
+  position: number
+): ReadonlyArray<number>;

types/bitwise/nibble/index.d.ts

@@ -0,0 +1,9 @@
+import nibbleRead from './read';
+import nibbleWrite from './write';
+
+declare namespace nibble {
+  const read: typeof nibbleRead;
+  const write: typeof nibbleWrite;
+}
+
+export default nibble;

types/bitwise/nibble/read.d.ts

@@ -0,0 +1 @@
+export default function read(nibble: number): ReadonlyArray<number>;

types/bitwise/nibble/write.d.ts

@@ -0,0 +1 @@
+export default function write(nibble: ReadonlyArray<number>): number;

types/bitwise/string/index.d.ts

@@ -0,0 +1,7 @@
+import stringToBits from './to-bits';
+
+declare namespace string {
+  const toBits: typeof stringToBits;
+}
+
+export default string;

types/bitwise/string/to-bits.d.ts

@@ -0,0 +1 @@
+export default function toBits(string: string): ReadonlyArray<number>;