new license file version [CI SKIP]
This commit is contained in:
@@ -0,0 +1,218 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
***************************************************************************** */
|
||||
/* global Reflect, Promise */
|
||||
|
||||
var extendStatics = function(d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
|
||||
export function __extends(d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
}
|
||||
|
||||
export var __assign = function() {
|
||||
__assign = Object.assign || function __assign(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
}
|
||||
return __assign.apply(this, arguments);
|
||||
}
|
||||
|
||||
export function __rest(s, e) {
|
||||
var t = {};
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
||||
t[p] = s[p];
|
||||
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
||||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
||||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
||||
t[p[i]] = s[p[i]];
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
export function __decorate(decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
}
|
||||
|
||||
export function __param(paramIndex, decorator) {
|
||||
return function (target, key) { decorator(target, key, paramIndex); }
|
||||
}
|
||||
|
||||
export function __metadata(metadataKey, metadataValue) {
|
||||
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
||||
}
|
||||
|
||||
export function __awaiter(thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
}
|
||||
|
||||
export function __generator(thisArg, body) {
|
||||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
||||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||||
function step(op) {
|
||||
if (f) throw new TypeError("Generator is already executing.");
|
||||
while (_) try {
|
||||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||||
switch (op[0]) {
|
||||
case 0: case 1: t = op; break;
|
||||
case 4: _.label++; return { value: op[1], done: false };
|
||||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||||
default:
|
||||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||||
if (t[2]) _.ops.pop();
|
||||
_.trys.pop(); continue;
|
||||
}
|
||||
op = body.call(thisArg, _);
|
||||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||||
}
|
||||
}
|
||||
|
||||
export function __createBinding(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}
|
||||
|
||||
export function __exportStar(m, exports) {
|
||||
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||
}
|
||||
|
||||
export function __values(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
}
|
||||
|
||||
export function __read(o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
}
|
||||
|
||||
export function __spread() {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++)
|
||||
ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
}
|
||||
|
||||
export function __spreadArrays() {
|
||||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
||||
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
||||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
||||
r[k] = a[j];
|
||||
return r;
|
||||
};
|
||||
|
||||
export function __await(v) {
|
||||
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
||||
}
|
||||
|
||||
export function __asyncGenerator(thisArg, _arguments, generator) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||||
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||||
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
||||
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||||
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||||
function fulfill(value) { resume("next", value); }
|
||||
function reject(value) { resume("throw", value); }
|
||||
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||||
}
|
||||
|
||||
export function __asyncDelegator(o) {
|
||||
var i, p;
|
||||
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
||||
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
|
||||
}
|
||||
|
||||
export function __asyncValues(o) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var m = o[Symbol.asyncIterator], i;
|
||||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||||
}
|
||||
|
||||
export function __makeTemplateObject(cooked, raw) {
|
||||
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
||||
return cooked;
|
||||
};
|
||||
|
||||
export function __importStar(mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||||
result.default = mod;
|
||||
return result;
|
||||
}
|
||||
|
||||
export function __importDefault(mod) {
|
||||
return (mod && mod.__esModule) ? mod : { default: mod };
|
||||
}
|
||||
|
||||
export function __classPrivateFieldGet(receiver, privateMap) {
|
||||
if (!privateMap.has(receiver)) {
|
||||
throw new TypeError("attempted to get private field on non-instance");
|
||||
}
|
||||
return privateMap.get(receiver);
|
||||
}
|
||||
|
||||
export function __classPrivateFieldSet(receiver, privateMap, value) {
|
||||
if (!privateMap.has(receiver)) {
|
||||
throw new TypeError("attempted to set private field on non-instance");
|
||||
}
|
||||
privateMap.set(receiver, value);
|
||||
return value;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"name": "rxjs/operators",
|
||||
"typings": "./index.d.ts",
|
||||
"main": "./index.js",
|
||||
"module": "../_esm5/operators/index.js",
|
||||
"es2015": "../_esm2015/operators/index.js",
|
||||
"sideEffects": false
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
let OldValue = require('../old-value')
|
||||
let Value = require('../value')
|
||||
|
||||
class Pixelated extends Value {
|
||||
/**
|
||||
* Use non-standard name for WebKit and Firefox
|
||||
*/
|
||||
replace (string, prefix) {
|
||||
if (prefix === '-webkit-') {
|
||||
return string.replace(this.regexp(), '$1-webkit-optimize-contrast')
|
||||
}
|
||||
if (prefix === '-moz-') {
|
||||
return string.replace(this.regexp(), '$1-moz-crisp-edges')
|
||||
}
|
||||
return super.replace(string, prefix)
|
||||
}
|
||||
|
||||
/**
|
||||
* Different name for WebKit and Firefox
|
||||
*/
|
||||
old (prefix) {
|
||||
if (prefix === '-webkit-') {
|
||||
return new OldValue(this.name, '-webkit-optimize-contrast')
|
||||
}
|
||||
if (prefix === '-moz-') {
|
||||
return new OldValue(this.name, '-moz-crisp-edges')
|
||||
}
|
||||
return super.old(prefix)
|
||||
}
|
||||
}
|
||||
|
||||
Pixelated.names = ['pixelated']
|
||||
|
||||
module.exports = Pixelated
|
||||
@@ -0,0 +1,11 @@
|
||||
import { ReplaySubject } from '../ReplaySubject';
|
||||
import { multicast } from './multicast';
|
||||
export function publishReplay(bufferSize, windowTime, selectorOrScheduler, scheduler) {
|
||||
if (selectorOrScheduler && typeof selectorOrScheduler !== 'function') {
|
||||
scheduler = selectorOrScheduler;
|
||||
}
|
||||
const selector = typeof selectorOrScheduler === 'function' ? selectorOrScheduler : undefined;
|
||||
const subject = new ReplaySubject(bufferSize, windowTime, scheduler);
|
||||
return (source) => multicast(() => subject, selector)(source);
|
||||
}
|
||||
//# sourceMappingURL=publishReplay.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Operator.js","sources":["../src/internal/Operator.ts"],"names":[],"mappings":""}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Scheduler.js","sources":["../src/internal/Scheduler.ts"],"names":[],"mappings":";;AAuBA;IASE,mBAAoB,eAA8B,EACtC,GAAiC;QAAjC,oBAAA,EAAA,MAAoB,SAAS,CAAC,GAAG;QADzB,oBAAe,GAAf,eAAe,CAAe;QAEhD,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IA6BM,4BAAQ,GAAf,UAAmB,IAAmD,EAAE,KAAiB,EAAE,KAAS;QAA5B,sBAAA,EAAA,SAAiB;QACvF,OAAO,IAAI,IAAI,CAAC,eAAe,CAAI,IAAI,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC;IApCa,aAAG,GAAiB,cAAM,OAAA,IAAI,CAAC,GAAG,EAAE,EAAV,CAAU,CAAC;IAqCrD,gBAAC;CAAA,AA5CD,IA4CC;AA5CY,8BAAS"}
|
||||
@@ -0,0 +1,10 @@
|
||||
/// <reference types="node" />
|
||||
import { Socket } from 'net';
|
||||
import { TLSSocket } from 'tls';
|
||||
interface Listeners {
|
||||
connect?: () => void;
|
||||
secureConnect?: () => void;
|
||||
close?: (hadError: boolean) => void;
|
||||
}
|
||||
declare const deferToConnect: (socket: Socket | TLSSocket, fn: Listeners | (() => void)) => void;
|
||||
export default deferToConnect;
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J E BC","132":"F G A B"},B:{"1":"P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t","132":"C K L H M N O"},C:{"1":"CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","132":"0 1 2 3 4 5 6 7 8 9 CC tB I u J E F G A B C K L H M N O v w x y z AB BB DC EC"},D:{"1":"vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","132":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB"},E:{"1":"sB 6B 7B 8B NC","2":"I u GC zB","132":"J E F G A B C K L H HC IC JC KC 0B qB rB 1B LC MC 2B 3B 4B 5B"},F:{"1":"OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d","2":"G OC PC QC RC","16":"B qB 9B","132":"0 1 2 3 4 5 6 7 8 9 C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB SC rB"},G:{"1":"sB 6B 7B 8B","16":"zB TC AC","132":"F UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B"},H:{"2":"nC"},I:{"1":"D","16":"oC pC","132":"tB I qC rC AC sC tC"},J:{"132":"E A"},K:{"1":"e","132":"A B C qB 9B rB"},L:{"1":"D"},M:{"1":"D"},N:{"132":"A B"},O:{"1":"uC"},P:{"132":"I vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C"},Q:{"1":"1B"},R:{"1":"8C"},S:{"1":"9C"}},B:5,C:"scrollIntoView"};
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"repeatWhen.js","sources":["../src/operators/repeatWhen.ts"],"names":[],"mappings":";;;;;AAAA,sDAAiD"}
|
||||
@@ -0,0 +1,60 @@
|
||||
type MapKey<BaseType> = BaseType extends Map<infer KeyType, unknown> ? KeyType : never;
|
||||
type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
|
||||
|
||||
export type ArrayEntry<BaseType extends readonly unknown[]> = [number, BaseType[number]];
|
||||
export type MapEntry<BaseType> = [MapKey<BaseType>, MapValue<BaseType>];
|
||||
export type ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
|
||||
export type SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
|
||||
|
||||
/**
|
||||
Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
|
||||
|
||||
For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
|
||||
|
||||
@see `Entries` if you want to just access the type of the array of entries (which is the return of the `.entries()` method).
|
||||
|
||||
@example
|
||||
```
|
||||
import {Entry} from 'type-fest';
|
||||
|
||||
interface Example {
|
||||
someKey: number;
|
||||
}
|
||||
|
||||
const manipulatesEntry = (example: Entry<Example>) => [
|
||||
// Does some arbitrary processing on the key (with type information available)
|
||||
example[0].toUpperCase(),
|
||||
|
||||
// Does some arbitrary processing on the value (with type information available)
|
||||
example[1].toFixed(),
|
||||
];
|
||||
|
||||
const example: Example = {someKey: 1};
|
||||
const entry = Object.entries(example)[0] as Entry<Example>;
|
||||
const output = manipulatesEntry(entry);
|
||||
|
||||
// Objects
|
||||
const objectExample = {a: 1};
|
||||
const objectEntry: Entry<typeof objectExample> = ['a', 1];
|
||||
|
||||
// Arrays
|
||||
const arrayExample = ['a', 1];
|
||||
const arrayEntryString: Entry<typeof arrayExample> = [0, 'a'];
|
||||
const arrayEntryNumber: Entry<typeof arrayExample> = [1, 1];
|
||||
|
||||
// Maps
|
||||
const mapExample = new Map([['a', 1]]);
|
||||
const mapEntry: Entry<typeof mapExample> = ['a', 1];
|
||||
|
||||
// Sets
|
||||
const setExample = new Set(['a', 1]);
|
||||
const setEntryString: Entry<typeof setExample> = ['a', 'a'];
|
||||
const setEntryNumber: Entry<typeof setExample> = [1, 1];
|
||||
```
|
||||
*/
|
||||
export type Entry<BaseType> =
|
||||
BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
|
||||
: BaseType extends Set<unknown> ? SetEntry<BaseType>
|
||||
: BaseType extends unknown[] ? ArrayEntry<BaseType>
|
||||
: BaseType extends object ? ObjectEntry<BaseType>
|
||||
: never;
|
||||
@@ -0,0 +1 @@
|
||||
import 'rxjs-compat/add/observable/merge';
|
||||
@@ -0,0 +1,12 @@
|
||||
import { ZipOperator } from '../observable/zip';
|
||||
import { Observable } from '../Observable';
|
||||
import { OperatorFunction, ObservableInput } from '../types';
|
||||
|
||||
export function zipAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;
|
||||
export function zipAll<T>(): OperatorFunction<any, T[]>;
|
||||
export function zipAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;
|
||||
export function zipAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;
|
||||
|
||||
export function zipAll<T, R>(project?: (...values: Array<any>) => R): OperatorFunction<T, R> {
|
||||
return (source: Observable<T>) => source.lift(new ZipOperator(project));
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
const path = require('path');
|
||||
const test = require('ava');
|
||||
const sh = require('shelljs');
|
||||
const proxyquire = require('proxyquire');
|
||||
const sinon = require('sinon');
|
||||
const Log = require('../lib/log');
|
||||
const Spinner = require('../lib/spinner');
|
||||
const Config = require('../lib/config');
|
||||
const Plugin = require('../lib/plugin/Plugin');
|
||||
const { mkTmpDir, gitAdd } = require('./util/helpers');
|
||||
const ShellStub = require('./stub/shell');
|
||||
|
||||
const noop = Promise.resolve();
|
||||
|
||||
const sandbox = sinon.createSandbox();
|
||||
|
||||
const testConfig = {
|
||||
ci: true,
|
||||
config: false,
|
||||
'disable-metrics': true
|
||||
};
|
||||
|
||||
const log = sandbox.createStubInstance(Log);
|
||||
const spinner = sandbox.createStubInstance(Spinner);
|
||||
spinner.show.callsFake(({ enabled = true, task }) => (enabled ? task() : noop));
|
||||
|
||||
const getContainer = options => {
|
||||
const config = new Config(Object.assign({}, testConfig, options));
|
||||
const shell = new ShellStub({ container: { log, config } });
|
||||
return {
|
||||
log,
|
||||
spinner,
|
||||
config,
|
||||
shell
|
||||
};
|
||||
};
|
||||
|
||||
test.serial.beforeEach(t => {
|
||||
const bare = mkTmpDir();
|
||||
const target = mkTmpDir();
|
||||
sh.pushd('-q', bare);
|
||||
sh.exec(`git init --bare .`);
|
||||
sh.exec(`git clone ${bare} ${target}`);
|
||||
sh.pushd('-q', target);
|
||||
gitAdd('line', 'file', 'Add file');
|
||||
t.context = { bare, target };
|
||||
});
|
||||
|
||||
test.serial.afterEach(() => {
|
||||
sandbox.resetHistory();
|
||||
});
|
||||
|
||||
const myPlugin = sandbox.createStubInstance(Plugin);
|
||||
myPlugin.namespace = 'my-plugin';
|
||||
const MyPlugin = sandbox.stub().callsFake(() => myPlugin);
|
||||
const myLocalPlugin = sandbox.createStubInstance(Plugin);
|
||||
const MyLocalPlugin = sandbox.stub().callsFake(() => myLocalPlugin);
|
||||
const replacePlugin = sandbox.createStubInstance(Plugin);
|
||||
const ReplacePlugin = sandbox.stub().callsFake(() => replacePlugin);
|
||||
|
||||
const staticMembers = { isEnabled: () => true, disablePlugin: () => null };
|
||||
const options = { '@global': true, '@noCallThru': true };
|
||||
const runTasks = proxyquire('../lib/tasks', {
|
||||
'my-plugin': Object.assign(MyPlugin, staticMembers, options),
|
||||
'/my/plugin': Object.assign(MyLocalPlugin, staticMembers, options),
|
||||
'replace-plugin': Object.assign(ReplacePlugin, staticMembers, options, {
|
||||
disablePlugin: () => ['version', 'git']
|
||||
})
|
||||
});
|
||||
|
||||
test.serial('should instantiate plugins and execute all release-cycle methods', async t => {
|
||||
const config = {
|
||||
plugins: {
|
||||
'my-plugin': {
|
||||
name: 'foo'
|
||||
},
|
||||
'/my/plugin': [
|
||||
'named-plugin',
|
||||
{
|
||||
name: 'bar'
|
||||
}
|
||||
]
|
||||
}
|
||||
};
|
||||
const container = getContainer(config);
|
||||
|
||||
await runTasks({}, container);
|
||||
|
||||
t.is(MyPlugin.firstCall.args[0].namespace, 'my-plugin');
|
||||
t.deepEqual(MyPlugin.firstCall.args[0].options['my-plugin'], { name: 'foo' });
|
||||
t.is(MyLocalPlugin.firstCall.args[0].namespace, 'named-plugin');
|
||||
t.deepEqual(MyLocalPlugin.firstCall.args[0].options['named-plugin'], { name: 'bar' });
|
||||
|
||||
[
|
||||
'init',
|
||||
'getName',
|
||||
'getLatestVersion',
|
||||
'getIncrement',
|
||||
'getIncrementedVersionCI',
|
||||
'beforeBump',
|
||||
'bump',
|
||||
'beforeRelease',
|
||||
'release',
|
||||
'afterRelease'
|
||||
].forEach(method => {
|
||||
t.is(myPlugin[method].callCount, 1);
|
||||
t.is(myLocalPlugin[method].callCount, 1);
|
||||
});
|
||||
|
||||
const incrementBase = { latestVersion: '0.0.0', increment: undefined, isPreRelease: false, preReleaseId: undefined };
|
||||
t.deepEqual(myPlugin.getIncrement.firstCall.args[0], incrementBase);
|
||||
t.deepEqual(myPlugin.getIncrementedVersionCI.firstCall.args[0], incrementBase);
|
||||
t.deepEqual(myLocalPlugin.getIncrementedVersionCI.firstCall.args[0], incrementBase);
|
||||
t.is(myPlugin.bump.firstCall.args[0], '0.0.1');
|
||||
t.is(myLocalPlugin.bump.firstCall.args[0], '0.0.1');
|
||||
});
|
||||
|
||||
test.serial('should disable core plugins', async t => {
|
||||
const config = {
|
||||
plugins: {
|
||||
'replace-plugin': {}
|
||||
}
|
||||
};
|
||||
const container = getContainer(config);
|
||||
|
||||
const result = await runTasks({}, container);
|
||||
|
||||
t.deepEqual(result, {
|
||||
changelog: undefined,
|
||||
name: undefined,
|
||||
latestVersion: undefined,
|
||||
version: undefined
|
||||
});
|
||||
});
|
||||
|
||||
test.serial('should expose context to execute commands', async t => {
|
||||
const { bare } = t.context;
|
||||
const latestVersion = '1.0.0';
|
||||
const project = path.basename(bare);
|
||||
const pkgName = 'plugin-context';
|
||||
const owner = path.basename(path.dirname(bare));
|
||||
gitAdd(`{"name":"${pkgName}","version":"${latestVersion}"}`, 'package.json', 'Add package.json');
|
||||
|
||||
class MyPlugin extends Plugin {
|
||||
init() {
|
||||
this.exec('echo ${version.isPreRelease}');
|
||||
}
|
||||
beforeBump() {
|
||||
const context = this.config.getContext();
|
||||
t.is(context.name, pkgName);
|
||||
this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version}');
|
||||
}
|
||||
bump() {
|
||||
const repo = this.config.getContext('repo');
|
||||
t.is(repo.owner, owner);
|
||||
t.is(repo.project, project);
|
||||
t.is(repo.repository, `${owner}/${project}`);
|
||||
this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version}');
|
||||
}
|
||||
beforeRelease() {
|
||||
const context = this.config.getContext();
|
||||
t.is(context.name, pkgName);
|
||||
this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
|
||||
}
|
||||
release() {
|
||||
const context = this.config.getContext();
|
||||
t.is(context.latestVersion, latestVersion);
|
||||
t.is(context.version, '1.0.1');
|
||||
this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
|
||||
}
|
||||
afterRelease() {
|
||||
const context = this.config.getContext();
|
||||
t.is(context.tagName, '1.0.1');
|
||||
this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
|
||||
}
|
||||
}
|
||||
const statics = { isEnabled: () => true, disablePlugin: () => null };
|
||||
const options = { '@global': true, '@noCallThru': true };
|
||||
const runTasks = proxyquire('../lib/tasks', {
|
||||
'my-plugin': Object.assign(MyPlugin, statics, options)
|
||||
});
|
||||
|
||||
const container = getContainer({ plugins: { 'my-plugin': {} } });
|
||||
const exec = sinon.spy(container.shell, 'execFormattedCommand');
|
||||
|
||||
await runTasks({}, container);
|
||||
|
||||
const pluginExecArgs = exec.args
|
||||
.map(args => args[0])
|
||||
.filter(arg => typeof arg === 'string' && arg.startsWith('echo'));
|
||||
|
||||
t.deepEqual(pluginExecArgs, [
|
||||
'echo false',
|
||||
`echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1`,
|
||||
`echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1`,
|
||||
`echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`,
|
||||
`echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`,
|
||||
`echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`
|
||||
]);
|
||||
});
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"race.js","sources":["../../../src/internal/observable/race.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAoD9D,MAAM,UAAU,IAAI;IAAI,qBAAsC;SAAtC,UAAsC,EAAtC,qBAAsC,EAAtC,IAAsC;QAAtC,gCAAsC;;IAG5D,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;QAC5B,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE;YAC3B,WAAW,GAAG,WAAW,CAAC,CAAC,CAAsB,CAAC;SACnD;aAAM;YACL,OAAO,WAAW,CAAC,CAAC,CAAkB,CAAC;SACxC;KACF;IAED,OAAO,SAAS,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,YAAY,EAAK,CAAC,CAAC;AACvE,CAAC;AAED;IAAA;IAIA,CAAC;IAHC,2BAAI,GAAJ,UAAK,UAAyB,EAAE,MAAW;QACzC,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1D,CAAC;IACH,mBAAC;AAAD,CAAC,AAJD,IAIC;;AAOD;IAAuC,0CAAqB;IAK1D,wBAAY,WAA0B;QAAtC,YACE,kBAAM,WAAW,CAAC,SACnB;QANO,cAAQ,GAAY,KAAK,CAAC;QAC1B,iBAAW,GAAsB,EAAE,CAAC;QACpC,mBAAa,GAAmB,EAAE,CAAC;;IAI3C,CAAC;IAES,8BAAK,GAAf,UAAgB,UAAe;QAC7B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC;IAES,kCAAS,GAAnB;QACE,IAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,IAAM,GAAG,GAAG,WAAW,CAAC,MAAM,CAAC;QAE/B,IAAI,GAAG,KAAK,CAAC,EAAE;YACb,IAAI,CAAC,WAAW,CAAC,QAAS,EAAE,CAAC;SAC9B;aAAM;YACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE;gBAC9C,IAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gBAClC,IAAM,YAAY,GAAG,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAE,CAAC;gBAExE,IAAI,IAAI,CAAC,aAAa,EAAE;oBACtB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;iBACvC;gBACD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aACxB;YACD,IAAI,CAAC,WAAW,GAAG,IAAK,CAAC;SAC1B;IACH,CAAC;IAED,mCAAU,GAAV,UAAW,WAAc,EAAE,UAAa,EAC7B,UAAkB;QAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAClD,IAAI,CAAC,KAAK,UAAU,EAAE;oBACpB,IAAI,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;oBAEzC,YAAY,CAAC,WAAW,EAAE,CAAC;oBAC3B,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;iBAC3B;aACF;YAED,IAAI,CAAC,aAAa,GAAG,IAAK,CAAC;SAC5B;QAED,IAAI,CAAC,WAAW,CAAC,IAAK,CAAC,UAAU,CAAC,CAAC;IACrC,CAAC;IACH,qBAAC;AAAD,CAAC,AApDD,CAAuC,eAAe,GAoDrD"}
|
||||
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"name": "resolve-from",
|
||||
"version": "5.0.0",
|
||||
"description": "Resolve the path of a module like `require.resolve()` but from a given path",
|
||||
"license": "MIT",
|
||||
"repository": "sindresorhus/resolve-from",
|
||||
"author": {
|
||||
"name": "Sindre Sorhus",
|
||||
"email": "sindresorhus@gmail.com",
|
||||
"url": "sindresorhus.com"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=8"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "xo && ava && tsd"
|
||||
},
|
||||
"files": [
|
||||
"index.js",
|
||||
"index.d.ts"
|
||||
],
|
||||
"keywords": [
|
||||
"require",
|
||||
"resolve",
|
||||
"path",
|
||||
"module",
|
||||
"from",
|
||||
"like",
|
||||
"import"
|
||||
],
|
||||
"devDependencies": {
|
||||
"ava": "^1.4.1",
|
||||
"tsd": "^0.7.2",
|
||||
"xo": "^0.24.0"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"race.js","sources":["../src/operator/race.ts"],"names":[],"mappings":";;;;;AAAA,+CAA0C"}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J E F G A B BC"},B:{"2":"C K L H M N O","132":"P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t"},C:{"2":"0 1 2 3 4 5 6 7 8 9 CC tB I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB DC EC"},D:{"16":"I u J E F G A B C K L H","132":"0 1 2 3 4 5 6 7 8 9 M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC"},E:{"1":"I u J E F G A B C K L H GC zB HC IC JC KC 0B qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B NC"},F:{"2":"G B C OC PC QC RC qB 9B SC rB","132":"0 1 2 3 4 5 6 7 8 9 H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d"},G:{"2":"F zB TC AC UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B"},H:{"2":"nC"},I:{"2":"tB I D oC pC qC rC AC sC tC"},J:{"2":"E A"},K:{"2":"A B C e qB 9B rB"},L:{"2":"D"},M:{"2":"D"},N:{"2":"A B"},O:{"2":"uC"},P:{"2":"I vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C"},Q:{"2":"1B"},R:{"2":"8C"},S:{"2":"9C"}},B:7,C:"CSS -webkit-user-drag property"};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"race.js","sources":["../../src/internal/operators/race.ts"],"names":[],"mappings":";;AACA,2CAA0C;AAE1C,2CAAwD;AAsBxD,SAAgB,IAAI;IAAI,qBAAmD;SAAnD,UAAmD,EAAnD,qBAAmD,EAAnD,IAAmD;QAAnD,gCAAmD;;IACzE,OAAO,SAAS,oBAAoB,CAAC,MAAqB;QAGxD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,IAAI,iBAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE;YACvD,WAAW,GAAG,WAAW,CAAC,CAAC,CAAoB,CAAC;SACjD;QAED,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAU,gBAAC,MAAM,SAAM,WAA+B,GAAE,CAAC;IACnF,CAAC,CAAC;AACJ,CAAC;AAVD,oBAUC"}
|
||||
@@ -0,0 +1,35 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = isLength;
|
||||
|
||||
var _assertString = _interopRequireDefault(require("./util/assertString"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||||
|
||||
/* eslint-disable prefer-rest-params */
|
||||
function isLength(str, options) {
|
||||
(0, _assertString.default)(str);
|
||||
var min;
|
||||
var max;
|
||||
|
||||
if (_typeof(options) === 'object') {
|
||||
min = options.min || 0;
|
||||
max = options.max;
|
||||
} else {
|
||||
// backwards compatibility: isLength(str, min [, max])
|
||||
min = arguments[1] || 0;
|
||||
max = arguments[2];
|
||||
}
|
||||
|
||||
var surrogatePairs = str.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
|
||||
var len = str.length - surrogatePairs.length;
|
||||
return len >= min && (typeof max === 'undefined' || len <= max);
|
||||
}
|
||||
|
||||
module.exports = exports.default;
|
||||
module.exports.default = exports.default;
|
||||
@@ -0,0 +1 @@
|
||||
export * from 'rxjs-compat/operator/switch';
|
||||
@@ -0,0 +1,62 @@
|
||||
# clone-response
|
||||
|
||||
> Clone a Node.js HTTP response stream
|
||||
|
||||
[](https://travis-ci.org/lukechilds/clone-response)
|
||||
[](https://coveralls.io/github/lukechilds/clone-response?branch=master)
|
||||
[](https://www.npmjs.com/package/clone-response)
|
||||
[](https://www.npmjs.com/package/clone-response)
|
||||
|
||||
Returns a new stream and copies over all properties and methods from the original response giving you a complete duplicate.
|
||||
|
||||
This is useful in situations where you need to consume the response stream but also want to pass an unconsumed stream somewhere else to be consumed later.
|
||||
|
||||
## Install
|
||||
|
||||
```shell
|
||||
npm install --save clone-response
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
const http = require('http');
|
||||
const cloneResponse = require('clone-response');
|
||||
|
||||
http.get('http://example.com', response => {
|
||||
const clonedResponse = cloneResponse(response);
|
||||
response.pipe(process.stdout);
|
||||
|
||||
setImmediate(() => {
|
||||
// The response stream has already been consumed by the time this executes,
|
||||
// however the cloned response stream is still available.
|
||||
doSomethingWithResponse(clonedResponse);
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
Please bear in mind that the process of cloning a stream consumes it. However, you can consume a stream multiple times in the same tick, therefore allowing you to create multiple clones. e.g:
|
||||
|
||||
```js
|
||||
const clone1 = cloneResponse(response);
|
||||
const clone2 = cloneResponse(response);
|
||||
// response can still be consumed in this tick but cannot be consumed if passed
|
||||
// into any async callbacks. clone1 and clone2 can be passed around and be
|
||||
// consumed in the future.
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### cloneResponse(response)
|
||||
|
||||
Returns a clone of the passed in response.
|
||||
|
||||
#### response
|
||||
|
||||
Type: `stream`
|
||||
|
||||
A [Node.js HTTP response stream](https://nodejs.org/api/http.html#http_class_http_incomingmessage) to clone.
|
||||
|
||||
## License
|
||||
|
||||
MIT © Luke Childs
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J E F G BC","132":"A B"},B:{"1":"P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t","132":"C K L H M N","516":"O"},C:{"1":"uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","2":"0 1 2 3 4 5 6 7 8 9 CC tB I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB DC EC"},D:{"1":"dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","2":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB","260":"bB cB"},E:{"1":"sB 6B 7B 8B NC","2":"I u J E F G A B C K L GC zB HC IC JC KC 0B qB rB 1B","1090":"H LC MC 2B 3B 4B 5B"},F:{"1":"SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d","2":"0 1 2 3 4 5 6 7 8 9 G B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB OC PC QC RC qB 9B SC rB","260":"QB RB"},G:{"1":"sB 6B 7B 8B","2":"F zB TC AC UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC","1090":"lC mC 2B 3B 4B 5B"},H:{"2":"nC"},I:{"1":"D","2":"tB I oC pC qC rC AC sC tC"},J:{"2":"E A"},K:{"1":"e","2":"A B C qB 9B rB"},L:{"1":"D"},M:{"1":"D"},N:{"132":"A B"},O:{"1":"uC"},P:{"1":"yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C","2":"I vC wC xC"},Q:{"1":"1B"},R:{"1":"8C"},S:{"2":"9C"}},B:5,C:"CSS overscroll-behavior"};
|
||||
@@ -0,0 +1,37 @@
|
||||
{
|
||||
"name": "commander",
|
||||
"version": "2.14.1",
|
||||
"description": "the complete solution for node.js command-line programs",
|
||||
"keywords": [
|
||||
"commander",
|
||||
"command",
|
||||
"option",
|
||||
"parser"
|
||||
],
|
||||
"author": "TJ Holowaychuk <tj@vision-media.ca>",
|
||||
"license": "MIT",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/tj/commander.js.git"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint index.js",
|
||||
"test": "make test && npm run test-typings",
|
||||
"test-typings": "node_modules/typescript/bin/tsc -p tsconfig.json"
|
||||
},
|
||||
"main": "index",
|
||||
"files": [
|
||||
"index.js",
|
||||
"typings/index.d.ts"
|
||||
],
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"@types/node": "^7.0.52",
|
||||
"eslint": "^3.19.0",
|
||||
"should": "^11.2.1",
|
||||
"sinon": "^2.4.1",
|
||||
"standard": "^10.0.3",
|
||||
"typescript": "^2.7.1"
|
||||
},
|
||||
"typings": "typings/index.d.ts"
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J E F G A B BC"},B:{"1":"p q r s D t","2":"C K L H M N O P Q R S T U V W X Y Z a b c d f g h i j k l m n o"},C:{"1":"t xB yB","2":"0 1 2 3 4 5 6 7 8 9 CC tB I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D DC EC"},D:{"1":"p q r s D t xB yB FC","2":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b","194":"l m n o","450":"c d f g h i j k"},E:{"1":"sB 6B 7B 8B NC","2":"I u J E F G A B C K L H GC zB HC IC JC KC 0B qB rB 1B LC MC 2B 3B 4B 5B"},F:{"1":"a b c d","2":"0 1 2 3 4 5 6 7 8 9 G B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB OC PC QC RC qB 9B SC rB","194":"P Q R wB S T U V W X Y Z"},G:{"1":"sB 6B 7B 8B","2":"F zB TC AC UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B"},H:{"2":"nC"},I:{"1":"D","2":"tB I oC pC qC rC AC sC tC"},J:{"2":"E A"},K:{"1":"e","2":"A B C qB 9B rB"},L:{"1":"D"},M:{"2":"D"},N:{"2":"A B"},O:{"2":"uC"},P:{"2":"I vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C"},Q:{"2":"1B"},R:{"2":"8C"},S:{"2":"9C"}},B:5,C:"CSS Container Query Units"};
|
||||
@@ -0,0 +1,91 @@
|
||||
import { Operator } from './Operator';
|
||||
import { Subscriber } from './Subscriber';
|
||||
import { Subscription } from './Subscription';
|
||||
import { TeardownLogic, OperatorFunction, PartialObserver, Subscribable } from './types';
|
||||
import { iif } from './observable/iif';
|
||||
import { throwError } from './observable/throwError';
|
||||
/**
|
||||
* A representation of any set of values over any amount of time. This is the most basic building block
|
||||
* of RxJS.
|
||||
*
|
||||
* @class Observable<T>
|
||||
*/
|
||||
export declare class Observable<T> implements Subscribable<T> {
|
||||
/** Internal implementation detail, do not use directly. */
|
||||
_isScalar: boolean;
|
||||
/** @deprecated This is an internal implementation detail, do not use. */
|
||||
source: Observable<any>;
|
||||
/** @deprecated This is an internal implementation detail, do not use. */
|
||||
operator: Operator<any, T>;
|
||||
/**
|
||||
* @constructor
|
||||
* @param {Function} subscribe the function that is called when the Observable is
|
||||
* initially subscribed to. This function is given a Subscriber, to which new values
|
||||
* can be `next`ed, or an `error` method can be called to raise an error, or
|
||||
* `complete` can be called to notify of a successful completion.
|
||||
*/
|
||||
constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
|
||||
/**
|
||||
* Creates a new cold Observable by calling the Observable constructor
|
||||
* @static true
|
||||
* @owner Observable
|
||||
* @method create
|
||||
* @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
|
||||
* @return {Observable} a new cold observable
|
||||
* @nocollapse
|
||||
* @deprecated use new Observable() instead
|
||||
*/
|
||||
static create: Function;
|
||||
/**
|
||||
* Creates a new Observable, with this Observable as the source, and the passed
|
||||
* operator defined as the new observable's operator.
|
||||
* @method lift
|
||||
* @param {Operator} operator the operator defining the operation to take on the observable
|
||||
* @return {Observable} a new observable with the Operator applied
|
||||
*/
|
||||
lift<R>(operator: Operator<T, R>): Observable<R>;
|
||||
subscribe(observer?: PartialObserver<T>): Subscription;
|
||||
/** @deprecated Use an observer instead of a complete callback */
|
||||
subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;
|
||||
/** @deprecated Use an observer instead of an error callback */
|
||||
subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Subscription;
|
||||
/** @deprecated Use an observer instead of a complete callback */
|
||||
subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Subscription;
|
||||
subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
|
||||
/** @deprecated This is an internal implementation detail, do not use. */
|
||||
_trySubscribe(sink: Subscriber<T>): TeardownLogic;
|
||||
/**
|
||||
* @method forEach
|
||||
* @param {Function} next a handler for each value emitted by the observable
|
||||
* @param {PromiseConstructor} [promiseCtor] a constructor function used to instantiate the Promise
|
||||
* @return {Promise} a promise that either resolves on observable completion or
|
||||
* rejects with the handled error
|
||||
*/
|
||||
forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void>;
|
||||
/** @internal This is an internal implementation detail, do not use. */
|
||||
_subscribe(subscriber: Subscriber<any>): TeardownLogic;
|
||||
/**
|
||||
* @nocollapse
|
||||
* @deprecated In favor of iif creation function: import { iif } from 'rxjs';
|
||||
*/
|
||||
static if: typeof iif;
|
||||
/**
|
||||
* @nocollapse
|
||||
* @deprecated In favor of throwError creation function: import { throwError } from 'rxjs';
|
||||
*/
|
||||
static throw: typeof throwError;
|
||||
pipe(): Observable<T>;
|
||||
pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
|
||||
pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
|
||||
pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
|
||||
pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
|
||||
pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
|
||||
pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
|
||||
pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
|
||||
pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
|
||||
pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
|
||||
pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<{}>;
|
||||
toPromise<T>(this: Observable<T>): Promise<T>;
|
||||
toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T>;
|
||||
toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T>;
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
export * from 'rxjs-compat/operators/mergeMapTo';
|
||||
@@ -0,0 +1,50 @@
|
||||
'use strict';
|
||||
const pump = require('pump');
|
||||
const bufferStream = require('./buffer-stream');
|
||||
|
||||
class MaxBufferError extends Error {
|
||||
constructor() {
|
||||
super('maxBuffer exceeded');
|
||||
this.name = 'MaxBufferError';
|
||||
}
|
||||
}
|
||||
|
||||
function getStream(inputStream, options) {
|
||||
if (!inputStream) {
|
||||
return Promise.reject(new Error('Expected a stream'));
|
||||
}
|
||||
|
||||
options = Object.assign({maxBuffer: Infinity}, options);
|
||||
|
||||
const {maxBuffer} = options;
|
||||
|
||||
let stream;
|
||||
return new Promise((resolve, reject) => {
|
||||
const rejectPromise = error => {
|
||||
if (error) { // A null check
|
||||
error.bufferedData = stream.getBufferedValue();
|
||||
}
|
||||
reject(error);
|
||||
};
|
||||
|
||||
stream = pump(inputStream, bufferStream(options), error => {
|
||||
if (error) {
|
||||
rejectPromise(error);
|
||||
return;
|
||||
}
|
||||
|
||||
resolve();
|
||||
});
|
||||
|
||||
stream.on('data', () => {
|
||||
if (stream.getBufferedLength() > maxBuffer) {
|
||||
rejectPromise(new MaxBufferError());
|
||||
}
|
||||
});
|
||||
}).then(() => stream.getBufferedValue());
|
||||
}
|
||||
|
||||
module.exports = getStream;
|
||||
module.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, {encoding: 'buffer'}));
|
||||
module.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, {array: true}));
|
||||
module.exports.MaxBufferError = MaxBufferError;
|
||||
@@ -0,0 +1,155 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
}
|
||||
return function (d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var Subject_1 = require("../Subject");
|
||||
var Observable_1 = require("../Observable");
|
||||
var Subscriber_1 = require("../Subscriber");
|
||||
var Subscription_1 = require("../Subscription");
|
||||
var refCount_1 = require("../operators/refCount");
|
||||
var ConnectableObservable = (function (_super) {
|
||||
__extends(ConnectableObservable, _super);
|
||||
function ConnectableObservable(source, subjectFactory) {
|
||||
var _this = _super.call(this) || this;
|
||||
_this.source = source;
|
||||
_this.subjectFactory = subjectFactory;
|
||||
_this._refCount = 0;
|
||||
_this._isComplete = false;
|
||||
return _this;
|
||||
}
|
||||
ConnectableObservable.prototype._subscribe = function (subscriber) {
|
||||
return this.getSubject().subscribe(subscriber);
|
||||
};
|
||||
ConnectableObservable.prototype.getSubject = function () {
|
||||
var subject = this._subject;
|
||||
if (!subject || subject.isStopped) {
|
||||
this._subject = this.subjectFactory();
|
||||
}
|
||||
return this._subject;
|
||||
};
|
||||
ConnectableObservable.prototype.connect = function () {
|
||||
var connection = this._connection;
|
||||
if (!connection) {
|
||||
this._isComplete = false;
|
||||
connection = this._connection = new Subscription_1.Subscription();
|
||||
connection.add(this.source
|
||||
.subscribe(new ConnectableSubscriber(this.getSubject(), this)));
|
||||
if (connection.closed) {
|
||||
this._connection = null;
|
||||
connection = Subscription_1.Subscription.EMPTY;
|
||||
}
|
||||
}
|
||||
return connection;
|
||||
};
|
||||
ConnectableObservable.prototype.refCount = function () {
|
||||
return refCount_1.refCount()(this);
|
||||
};
|
||||
return ConnectableObservable;
|
||||
}(Observable_1.Observable));
|
||||
exports.ConnectableObservable = ConnectableObservable;
|
||||
exports.connectableObservableDescriptor = (function () {
|
||||
var connectableProto = ConnectableObservable.prototype;
|
||||
return {
|
||||
operator: { value: null },
|
||||
_refCount: { value: 0, writable: true },
|
||||
_subject: { value: null, writable: true },
|
||||
_connection: { value: null, writable: true },
|
||||
_subscribe: { value: connectableProto._subscribe },
|
||||
_isComplete: { value: connectableProto._isComplete, writable: true },
|
||||
getSubject: { value: connectableProto.getSubject },
|
||||
connect: { value: connectableProto.connect },
|
||||
refCount: { value: connectableProto.refCount }
|
||||
};
|
||||
})();
|
||||
var ConnectableSubscriber = (function (_super) {
|
||||
__extends(ConnectableSubscriber, _super);
|
||||
function ConnectableSubscriber(destination, connectable) {
|
||||
var _this = _super.call(this, destination) || this;
|
||||
_this.connectable = connectable;
|
||||
return _this;
|
||||
}
|
||||
ConnectableSubscriber.prototype._error = function (err) {
|
||||
this._unsubscribe();
|
||||
_super.prototype._error.call(this, err);
|
||||
};
|
||||
ConnectableSubscriber.prototype._complete = function () {
|
||||
this.connectable._isComplete = true;
|
||||
this._unsubscribe();
|
||||
_super.prototype._complete.call(this);
|
||||
};
|
||||
ConnectableSubscriber.prototype._unsubscribe = function () {
|
||||
var connectable = this.connectable;
|
||||
if (connectable) {
|
||||
this.connectable = null;
|
||||
var connection = connectable._connection;
|
||||
connectable._refCount = 0;
|
||||
connectable._subject = null;
|
||||
connectable._connection = null;
|
||||
if (connection) {
|
||||
connection.unsubscribe();
|
||||
}
|
||||
}
|
||||
};
|
||||
return ConnectableSubscriber;
|
||||
}(Subject_1.SubjectSubscriber));
|
||||
var RefCountOperator = (function () {
|
||||
function RefCountOperator(connectable) {
|
||||
this.connectable = connectable;
|
||||
}
|
||||
RefCountOperator.prototype.call = function (subscriber, source) {
|
||||
var connectable = this.connectable;
|
||||
connectable._refCount++;
|
||||
var refCounter = new RefCountSubscriber(subscriber, connectable);
|
||||
var subscription = source.subscribe(refCounter);
|
||||
if (!refCounter.closed) {
|
||||
refCounter.connection = connectable.connect();
|
||||
}
|
||||
return subscription;
|
||||
};
|
||||
return RefCountOperator;
|
||||
}());
|
||||
var RefCountSubscriber = (function (_super) {
|
||||
__extends(RefCountSubscriber, _super);
|
||||
function RefCountSubscriber(destination, connectable) {
|
||||
var _this = _super.call(this, destination) || this;
|
||||
_this.connectable = connectable;
|
||||
return _this;
|
||||
}
|
||||
RefCountSubscriber.prototype._unsubscribe = function () {
|
||||
var connectable = this.connectable;
|
||||
if (!connectable) {
|
||||
this.connection = null;
|
||||
return;
|
||||
}
|
||||
this.connectable = null;
|
||||
var refCount = connectable._refCount;
|
||||
if (refCount <= 0) {
|
||||
this.connection = null;
|
||||
return;
|
||||
}
|
||||
connectable._refCount = refCount - 1;
|
||||
if (refCount > 1) {
|
||||
this.connection = null;
|
||||
return;
|
||||
}
|
||||
var connection = this.connection;
|
||||
var sharedConnection = connectable._connection;
|
||||
this.connection = null;
|
||||
if (sharedConnection && (!connection || sharedConnection === connection)) {
|
||||
sharedConnection.unsubscribe();
|
||||
}
|
||||
};
|
||||
return RefCountSubscriber;
|
||||
}(Subscriber_1.Subscriber));
|
||||
//# sourceMappingURL=ConnectableObservable.js.map
|
||||
@@ -0,0 +1,43 @@
|
||||
import { AsapAction } from './AsapAction';
|
||||
import { AsapScheduler } from './AsapScheduler';
|
||||
|
||||
/**
|
||||
*
|
||||
* Asap Scheduler
|
||||
*
|
||||
* <span class="informal">Perform task as fast as it can be performed asynchronously</span>
|
||||
*
|
||||
* `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task
|
||||
* in time. If however you set delay to `0`, `asap` will wait for current synchronously executing
|
||||
* code to end and then it will try to execute given task as fast as possible.
|
||||
*
|
||||
* `asap` scheduler will do its best to minimize time between end of currently executing code
|
||||
* and start of scheduled task. This makes it best candidate for performing so called "deferring".
|
||||
* Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves
|
||||
* some (although minimal) unwanted delay.
|
||||
*
|
||||
* Note that using `asap` scheduler does not necessarily mean that your task will be first to process
|
||||
* after currently executing code. In particular, if some task was also scheduled with `asap` before,
|
||||
* that task will execute first. That being said, if you need to schedule task asynchronously, but
|
||||
* as soon as possible, `asap` scheduler is your best bet.
|
||||
*
|
||||
* ## Example
|
||||
* Compare async and asap scheduler<
|
||||
* ```ts
|
||||
* import { asapScheduler, asyncScheduler } from 'rxjs';
|
||||
*
|
||||
* asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first...
|
||||
* asapScheduler.schedule(() => console.log('asap'));
|
||||
*
|
||||
* // Logs:
|
||||
* // "asap"
|
||||
* // "async"
|
||||
* // ... but 'asap' goes first!
|
||||
* ```
|
||||
*/
|
||||
export const asapScheduler = new AsapScheduler(AsapAction);
|
||||
|
||||
/**
|
||||
* @deprecated renamed. Use {@link asapScheduler}
|
||||
*/
|
||||
export const asap = asapScheduler;
|
||||
Reference in New Issue
Block a user