diff options
Diffstat (limited to 'sandbox/testAppNevena/Front/node_modules/rxjs/src')
28 files changed, 1159 insertions, 0 deletions
diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/README.md b/sandbox/testAppNevena/Front/node_modules/rxjs/src/README.md new file mode 100644 index 00000000..f92dafde --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/README.md @@ -0,0 +1,147 @@ +# <img src="docs_app/assets/Rx_Logo_S.png" alt="RxJS Logo" width="86" height="86"> RxJS: Reactive Extensions For JavaScript + +[](https://circleci.com/gh/ReactiveX/rxjs/tree/6.x) +[](http://badge.fury.io/js/%40reactivex%2Frxjs) +[](https://gitter.im/Reactive-Extensions/RxJS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +# RxJS 6 Stable + +### MIGRATION AND RELEASE INFORMATION: + +Find out how to update to v6, **automatically update your TypeScript code**, and more! + +- [Current home is MIGRATION.md](./docs_app/content/guide/v6/migration.md) + +### FOR V 5.X PLEASE GO TO [THE 5.0 BRANCH](https://github.com/ReactiveX/rxjs/tree/5.x) + +Reactive Extensions Library for JavaScript. This is a rewrite of [Reactive-Extensions/RxJS](https://github.com/Reactive-Extensions/RxJS) and is the latest production-ready version of RxJS. This rewrite is meant to have better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface. + +[Apache 2.0 License](LICENSE.txt) + +- [Code of Conduct](CODE_OF_CONDUCT.md) +- [Contribution Guidelines](CONTRIBUTING.md) +- [Maintainer Guidelines](doc_app/content/maintainer-guidelines.md) +- [API Documentation](https://rxjs.dev/) + +## Versions In This Repository + +- [master](https://github.com/ReactiveX/rxjs/commits/master) - This is all of the current, unreleased work, which is against v6 of RxJS right now +- [stable](https://github.com/ReactiveX/rxjs/commits/stable) - This is the branch for the latest version you'd get if you do `npm install rxjs` + +## Important + +By contributing or commenting on issues in this repository, whether you've read them or not, you're agreeing to the [Contributor Code of Conduct](CODE_OF_CONDUCT.md). Much like traffic laws, ignorance doesn't grant you immunity. + +## Installation and Usage + +### ES6 via npm + +```sh +npm install rxjs +``` + +It's recommended to pull in the Observable creation methods you need directly from `'rxjs'` as shown below with `range`. And you can pull in any operator you need from one spot, under `'rxjs/operators'`. + +```ts +import { range } from "rxjs"; +import { map, filter } from "rxjs/operators"; + +range(1, 200) + .pipe( + filter(x => x % 2 === 1), + map(x => x + x) + ) + .subscribe(x => console.log(x)); +``` + +Here, we're using the built-in `pipe` method on Observables to combine operators. See [pipeable operators](https://github.com/ReactiveX/rxjs/blob/master/doc/pipeable-operators.md) for more information. + +### CommonJS via npm + +To install this library for CommonJS (CJS) usage, use the following command: + +```sh +npm install rxjs +``` + +(Note: destructuring available in Node 8+) + +```js +const { range } = require('rxjs'); +const { map, filter } = require('rxjs/operators'); + +range(1, 200).pipe( + filter(x => x % 2 === 1), + map(x => x + x) +).subscribe(x => console.log(x)); +``` + +### CDN + +For CDN, you can use [unpkg](https://unpkg.com/): + +https://unpkg.com/rxjs/bundles/rxjs.umd.min.js + +The global namespace for rxjs is `rxjs`: + +```js +const { range } = rxjs; +const { map, filter } = rxjs.operators; + +range(1, 200) + .pipe( + filter(x => x % 2 === 1), + map(x => x + x) + ) + .subscribe(x => console.log(x)); +``` + +## Goals + +- Smaller overall bundles sizes +- Provide better performance than preceding versions of RxJS +- To model/follow the [Observable Spec Proposal](https://github.com/zenparsing/es-observable) to the observable +- Provide more modular file structure in a variety of formats +- Provide more debuggable call stacks than preceding versions of RxJS + +## Building/Testing + +- `npm run build_all` - builds everything +- `npm test` - runs tests +- `npm run test_no_cache` - run test with `ts-node` set to false + +## Performance Tests + +Run `npm run build_perf` or `npm run perf` to run the performance tests with `protractor`. + +Run `npm run perf_micro [operator]` to run micro performance test benchmarking operator. + +## Adding documentation + +We appreciate all contributions to the documentation of any type. All of the information needed to get the docs app up and running locally as well as how to contribute can be found in the [documentation directory](./docs_app). + +## Generating PNG marble diagrams + +The script `npm run tests2png` requires some native packages installed locally: `imagemagick`, `graphicsmagick`, and `ghostscript`. + +For Mac OS X with [Homebrew](http://brew.sh/): + +- `brew install imagemagick` +- `brew install graphicsmagick` +- `brew install ghostscript` +- You may need to install the Ghostscript fonts manually: + - Download the tarball from the [gs-fonts project](https://sourceforge.net/projects/gs-fonts) + - `mkdir -p /usr/local/share/ghostscript && tar zxvf /path/to/ghostscript-fonts.tar.gz -C /usr/local/share/ghostscript` + +For Debian Linux: + +- `sudo add-apt-repository ppa:dhor/myway` +- `apt-get install imagemagick` +- `apt-get install graphicsmagick` +- `apt-get install ghostscript` + +For Windows and other Operating Systems, check the download instructions here: + +- http://imagemagick.org +- http://www.graphicsmagick.org +- http://www.ghostscript.com/ diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/Rx.global.js b/sandbox/testAppNevena/Front/node_modules/rxjs/src/Rx.global.js new file mode 100644 index 00000000..d75682b2 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/Rx.global.js @@ -0,0 +1,5 @@ +(function (root, factory) { + root.Rx = factory(); +})(window || global || this, function () { + return require('../dist/package/Rx'); +});
\ No newline at end of file diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/add/observable/dom/ajax.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/add/observable/dom/ajax.ts new file mode 100644 index 00000000..2b32efef --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/add/observable/dom/ajax.ts @@ -0,0 +1 @@ +import 'rxjs-compat/add/observable/dom/ajax'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/ajax/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/ajax/package.json new file mode 100644 index 00000000..898cd05d --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/ajax/package.json @@ -0,0 +1,8 @@ +{ + "name": "rxjs/ajax", + "typings": "./index.d.ts", + "main": "./index.js", + "module": "../_esm5/ajax/index.js", + "es2015": "../_esm2015/ajax/index.js", + "sideEffects": false +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/fetch/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/fetch/package.json new file mode 100644 index 00000000..dff55196 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/fetch/package.json @@ -0,0 +1,8 @@ +{ + "name": "rxjs/fetch", + "typings": "./index.d.ts", + "main": "./index.js", + "module": "../_esm5/fetch/index.js", + "es2015": "../_esm2015/fetch/index.js", + "sideEffects": false +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal-compatibility/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal-compatibility/package.json new file mode 100644 index 00000000..5ff05a69 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal-compatibility/package.json @@ -0,0 +1,8 @@ +{ + "name": "rxjs/internal-compatibility", + "typings": "./index.d.ts", + "main": "./index.js", + "module": "../_esm5/internal-compatibility/index.js", + "es2015": "../_esm2015/internal-compatibility/index.js", + "sideEffects": false +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/AjaxObservable.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/AjaxObservable.ts new file mode 100644 index 00000000..d1f3f918 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/AjaxObservable.ts @@ -0,0 +1,550 @@ +import { root } from '../../util/root'; +import { Observable } from '../../Observable'; +import { Subscriber } from '../../Subscriber'; +import { TeardownLogic } from '../../types'; +import { map } from '../../operators/map'; + +export interface AjaxRequest { + url?: string; + body?: any; + user?: string; + async?: boolean; + method?: string; + headers?: Object; + timeout?: number; + password?: string; + hasContent?: boolean; + crossDomain?: boolean; + withCredentials?: boolean; + createXHR?: () => XMLHttpRequest; + progressSubscriber?: Subscriber<any>; + responseType?: string; +} + +function getCORSRequest(): XMLHttpRequest { + if (root.XMLHttpRequest) { + return new root.XMLHttpRequest(); + } else if (!!root.XDomainRequest) { + return new root.XDomainRequest(); + } else { + throw new Error('CORS is not supported by your browser'); + } +} + +function getXMLHttpRequest(): XMLHttpRequest { + if (root.XMLHttpRequest) { + return new root.XMLHttpRequest(); + } else { + let progId: string; + try { + const progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0']; + for (let i = 0; i < 3; i++) { + try { + progId = progIds[i]; + if (new root.ActiveXObject(progId)) { + break; + } + } catch (e) { + //suppress exceptions + } + } + return new root.ActiveXObject(progId); + } catch (e) { + throw new Error('XMLHttpRequest is not supported by your browser'); + } + } +} + +export interface AjaxCreationMethod { + (urlOrRequest: string | AjaxRequest): Observable<AjaxResponse>; + get(url: string, headers?: Object): Observable<AjaxResponse>; + post(url: string, body?: any, headers?: Object): Observable<AjaxResponse>; + put(url: string, body?: any, headers?: Object): Observable<AjaxResponse>; + patch(url: string, body?: any, headers?: Object): Observable<AjaxResponse>; + delete(url: string, headers?: Object): Observable<AjaxResponse>; + getJSON<T>(url: string, headers?: Object): Observable<T>; +} + +export function ajaxGet(url: string, headers: Object = null) { + return new AjaxObservable<AjaxResponse>({ method: 'GET', url, headers }); +} + +export function ajaxPost(url: string, body?: any, headers?: Object): Observable<AjaxResponse> { + return new AjaxObservable<AjaxResponse>({ method: 'POST', url, body, headers }); +} + +export function ajaxDelete(url: string, headers?: Object): Observable<AjaxResponse> { + return new AjaxObservable<AjaxResponse>({ method: 'DELETE', url, headers }); +} + +export function ajaxPut(url: string, body?: any, headers?: Object): Observable<AjaxResponse> { + return new AjaxObservable<AjaxResponse>({ method: 'PUT', url, body, headers }); +} + +export function ajaxPatch(url: string, body?: any, headers?: Object): Observable<AjaxResponse> { + return new AjaxObservable<AjaxResponse>({ method: 'PATCH', url, body, headers }); +} + +const mapResponse = map((x: AjaxResponse, index: number) => x.response); + +export function ajaxGetJSON<T>(url: string, headers?: Object): Observable<T> { + return mapResponse( + new AjaxObservable<AjaxResponse>({ + method: 'GET', + url, + responseType: 'json', + headers + }) + ); +} + +/** + * We need this JSDoc comment for affecting ESDoc. + * @extends {Ignored} + * @hide true + */ +export class AjaxObservable<T> extends Observable<T> { + /** + * Creates an observable for an Ajax request with either a request object with + * url, headers, etc or a string for a URL. + * + * ## Example + * ```ts + * import { ajax } from 'rxjs/ajax'; + * + * const source1 = ajax('/products'); + * const source2 = ajax({ url: 'products', method: 'GET' }); + * ``` + * + * @param {string|Object} request Can be one of the following: + * A string of the URL to make the Ajax call. + * An object with the following properties + * - url: URL of the request + * - body: The body of the request + * - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE + * - async: Whether the request is async + * - headers: Optional headers + * - crossDomain: true if a cross domain request, else false + * - createXHR: a function to override if you need to use an alternate + * XMLHttpRequest implementation. + * - resultSelector: a function to use to alter the output value type of + * the Observable. Gets {@link AjaxResponse} as an argument. + * @return {Observable} An observable sequence containing the XMLHttpRequest. + * @static true + * @name ajax + * @owner Observable + * @nocollapse + */ + static create: AjaxCreationMethod = (() => { + const create: any = (urlOrRequest: string | AjaxRequest) => { + return new AjaxObservable(urlOrRequest); + }; + + create.get = ajaxGet; + create.post = ajaxPost; + create.delete = ajaxDelete; + create.put = ajaxPut; + create.patch = ajaxPatch; + create.getJSON = ajaxGetJSON; + + return <AjaxCreationMethod>create; + })(); + + private request: AjaxRequest; + + constructor(urlOrRequest: string | AjaxRequest) { + super(); + + const request: AjaxRequest = { + async: true, + createXHR: function(this: AjaxRequest) { + return this.crossDomain ? getCORSRequest() : getXMLHttpRequest(); + }, + crossDomain: true, + withCredentials: false, + headers: {}, + method: 'GET', + responseType: 'json', + timeout: 0 + }; + + if (typeof urlOrRequest === 'string') { + request.url = urlOrRequest; + } else { + for (const prop in urlOrRequest) { + if (urlOrRequest.hasOwnProperty(prop)) { + request[prop] = urlOrRequest[prop]; + } + } + } + + this.request = request; + } + + /** @deprecated This is an internal implementation detail, do not use. */ + _subscribe(subscriber: Subscriber<T>): TeardownLogic { + return new AjaxSubscriber(subscriber, this.request); + } +} + +/** + * We need this JSDoc comment for affecting ESDoc. + * @ignore + * @extends {Ignored} + */ +export class AjaxSubscriber<T> extends Subscriber<Event> { + private xhr: XMLHttpRequest; + private done: boolean = false; + + constructor(destination: Subscriber<T>, public request: AjaxRequest) { + super(destination); + + const headers = request.headers = request.headers || {}; + + // force CORS if requested + if (!request.crossDomain && !this.getHeader(headers, 'X-Requested-With')) { + headers['X-Requested-With'] = 'XMLHttpRequest'; + } + + // ensure content type is set + let contentTypeHeader = this.getHeader(headers, 'Content-Type'); + if (!contentTypeHeader && !(root.FormData && request.body instanceof root.FormData) && typeof request.body !== 'undefined') { + headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'; + } + + // properly serialize body + request.body = this.serializeBody(request.body, this.getHeader(request.headers, 'Content-Type')); + + this.send(); + } + + next(e: Event): void { + this.done = true; + const { xhr, request, destination } = this; + let result; + try { + result = new AjaxResponse(e, xhr, request); + } catch (err) { + return destination.error(err); + } + destination.next(result); + } + + private send(): void { + const { + request, + request: { user, method, url, async, password, headers, body } + } = this; + try { + const xhr = this.xhr = request.createXHR(); + + // set up the events before open XHR + // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest + // You need to add the event listeners before calling open() on the request. + // Otherwise the progress events will not fire. + this.setupEvents(xhr, request); + // open XHR + if (user) { + xhr.open(method, url, async, user, password); + } else { + xhr.open(method, url, async); + } + + // timeout, responseType and withCredentials can be set once the XHR is open + if (async) { + xhr.timeout = request.timeout; + xhr.responseType = request.responseType as any; + } + + if ('withCredentials' in xhr) { + xhr.withCredentials = !!request.withCredentials; + } + + // set headers + this.setHeaders(xhr, headers); + + // finally send the request + if (body) { + xhr.send(body); + } else { + xhr.send(); + } + } catch (err) { + this.error(err); + } + } + + private serializeBody(body: any, contentType?: string) { + if (!body || typeof body === 'string') { + return body; + } else if (root.FormData && body instanceof root.FormData) { + return body; + } + + if (contentType) { + const splitIndex = contentType.indexOf(';'); + if (splitIndex !== -1) { + contentType = contentType.substring(0, splitIndex); + } + } + + switch (contentType) { + case 'application/x-www-form-urlencoded': + return Object.keys(body).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(body[key])}`).join('&'); + case 'application/json': + return JSON.stringify(body); + default: + return body; + } + } + + private setHeaders(xhr: XMLHttpRequest, headers: Object) { + for (let key in headers) { + if (headers.hasOwnProperty(key)) { + xhr.setRequestHeader(key, headers[key]); + } + } + } + + private getHeader(headers: {}, headerName: string): any { + for (let key in headers) { + if (key.toLowerCase() === headerName.toLowerCase()) { + return headers[key]; + } + } + + return undefined; + } + + private setupEvents(xhr: XMLHttpRequest, request: AjaxRequest) { + const progressSubscriber = request.progressSubscriber; + + function xhrTimeout(this: XMLHttpRequest, e: ProgressEvent): void { + const {subscriber, progressSubscriber, request } = (<any>xhrTimeout); + if (progressSubscriber) { + progressSubscriber.error(e); + } + let error; + try { + error = new AjaxTimeoutError(this, request); // TODO: Make betterer. + } catch (err) { + error = err; + } + subscriber.error(error); + } + xhr.ontimeout = xhrTimeout; + (<any>xhrTimeout).request = request; + (<any>xhrTimeout).subscriber = this; + (<any>xhrTimeout).progressSubscriber = progressSubscriber; + if (xhr.upload && 'withCredentials' in xhr) { + if (progressSubscriber) { + let xhrProgress: (e: ProgressEvent) => void; + xhrProgress = function(e: ProgressEvent) { + const { progressSubscriber } = (<any>xhrProgress); + progressSubscriber.next(e); + }; + if (root.XDomainRequest) { + xhr.onprogress = xhrProgress; + } else { + xhr.upload.onprogress = xhrProgress; + } + (<any>xhrProgress).progressSubscriber = progressSubscriber; + } + let xhrError: (e: any) => void; + xhrError = function(this: XMLHttpRequest, e: ErrorEvent) { + const { progressSubscriber, subscriber, request } = (<any>xhrError); + if (progressSubscriber) { + progressSubscriber.error(e); + } + let error; + try { + error = new AjaxError('ajax error', this, request); + } catch (err) { + error = err; + } + subscriber.error(error); + }; + xhr.onerror = xhrError; + (<any>xhrError).request = request; + (<any>xhrError).subscriber = this; + (<any>xhrError).progressSubscriber = progressSubscriber; + } + + function xhrReadyStateChange(this: XMLHttpRequest, e: Event) { + return; + } + xhr.onreadystatechange = xhrReadyStateChange; + (<any>xhrReadyStateChange).subscriber = this; + (<any>xhrReadyStateChange).progressSubscriber = progressSubscriber; + (<any>xhrReadyStateChange).request = request; + + function xhrLoad(this: XMLHttpRequest, e: Event) { + const { subscriber, progressSubscriber, request } = (<any>xhrLoad); + if (this.readyState === 4) { + // normalize IE9 bug (http://bugs.jquery.com/ticket/1450) + let status: number = this.status === 1223 ? 204 : this.status; + let response: any = (this.responseType === 'text' ? ( + this.response || this.responseText) : this.response); + + // fix status code when it is 0 (0 status is undocumented). + // Occurs when accessing file resources or on Android 4.1 stock browser + // while retrieving files from application cache. + if (status === 0) { + status = response ? 200 : 0; + } + + // 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html) + if (status < 400) { + if (progressSubscriber) { + progressSubscriber.complete(); + } + subscriber.next(e); + subscriber.complete(); + } else { + if (progressSubscriber) { + progressSubscriber.error(e); + } + let error; + try { + error = new AjaxError('ajax error ' + status, this, request); + } catch (err) { + error = err; + } + subscriber.error(error); + } + } + } + xhr.onload = xhrLoad; + (<any>xhrLoad).subscriber = this; + (<any>xhrLoad).progressSubscriber = progressSubscriber; + (<any>xhrLoad).request = request; + } + + unsubscribe() { + const { done, xhr } = this; + if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') { + xhr.abort(); + } + super.unsubscribe(); + } +} + +/** + * A normalized AJAX response. + * + * @see {@link ajax} + * + * @class AjaxResponse + */ +export class AjaxResponse { + /** @type {number} The HTTP status code */ + status: number; + + /** @type {string|ArrayBuffer|Document|object|any} The response data */ + response: any; + + /** @type {string} The raw responseText */ + responseText: string; + + /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */ + responseType: string; + + constructor(public originalEvent: Event, public xhr: XMLHttpRequest, public request: AjaxRequest) { + this.status = xhr.status; + this.responseType = xhr.responseType || request.responseType; + this.response = parseXhrResponse(this.responseType, xhr); + } +} + +export type AjaxErrorNames = 'AjaxError' | 'AjaxTimeoutError'; + +/** + * A normalized AJAX error. + * + * @see {@link ajax} + * + * @class AjaxError + */ +export interface AjaxError extends Error { + /** @type {XMLHttpRequest} The XHR instance associated with the error */ + xhr: XMLHttpRequest; + + /** @type {AjaxRequest} The AjaxRequest associated with the error */ + request: AjaxRequest; + + /** @type {number} The HTTP status code */ + status: number; + + /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */ + responseType: string; + + /** @type {string|ArrayBuffer|Document|object|any} The response data */ + response: any; +} + +export interface AjaxErrorCtor { + new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError; +} + +const AjaxErrorImpl = (() => { + function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError { + Error.call(this); + this.message = message; + this.name = 'AjaxError'; + this.xhr = xhr; + this.request = request; + this.status = xhr.status; + this.responseType = xhr.responseType || request.responseType; + this.response = parseXhrResponse(this.responseType, xhr); + return this; + } + AjaxErrorImpl.prototype = Object.create(Error.prototype); + return AjaxErrorImpl; +})(); + +export const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any; + +function parseJson(xhr: XMLHttpRequest) { + // HACK(benlesh): TypeScript shennanigans + // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else clause. + if ('response' in (xhr as any)) { + //IE does not support json as responseType, parse it internally + return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null'); + } else { + return JSON.parse((xhr as any).responseText || 'null'); + } +} + +function parseXhrResponse(responseType: string, xhr: XMLHttpRequest) { + switch (responseType) { + case 'json': + return parseJson(xhr); + case 'xml': + return xhr.responseXML; + case 'text': + default: + // HACK(benlesh): TypeScript shennanigans + // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else sub-expression. + return ('response' in (xhr as any)) ? xhr.response : xhr.responseText; + } +} + +export interface AjaxTimeoutError extends AjaxError { +} + +export interface AjaxTimeoutErrorCtor { + new(xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError; +} + +function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) { + AjaxError.call(this, 'ajax timeout', xhr, request); + this.name = 'AjaxTimeoutError'; + return this; +} + +/** + * @see {@link ajax} + * + * @class AjaxTimeoutError + */ +export const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/ajax.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/ajax.ts new file mode 100644 index 00000000..d0885c1d --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/observable/dom/ajax.ts @@ -0,0 +1,82 @@ +import { AjaxObservable, AjaxCreationMethod } from './AjaxObservable'; +/** + * There is an ajax operator on the Rx object. + * + * It creates an observable for an Ajax request with either a request object with + * url, headers, etc or a string for a URL. + * + * + * ## Using ajax() to fetch the response object that is being returned from API. + * ```ts + * import { ajax } from 'rxjs/ajax'; + * import { map, catchError } from 'rxjs/operators'; + * import { of } from 'rxjs'; + * + * const obs$ = ajax(`https://api.github.com/users?per_page=5`).pipe( + * map(userResponse => console.log('users: ', userResponse)), + * catchError(error => { + * console.log('error: ', error); + * return of(error); + * }) + * ); + * + * ``` + * + * ## Using ajax.getJSON() to fetch data from API. + * ```ts + * import { ajax } from 'rxjs/ajax'; + * import { map, catchError } from 'rxjs/operators'; + * import { of } from 'rxjs'; + * + * const obs$ = ajax.getJSON(`https://api.github.com/users?per_page=5`).pipe( + * map(userResponse => console.log('users: ', userResponse)), + * catchError(error => { + * console.log('error: ', error); + * return of(error); + * }) + * ); + * + * ``` + * + * ## Using ajax() with object as argument and method POST with a two seconds delay. + * ```ts + * import { ajax } from 'rxjs/ajax'; + * import { of } from 'rxjs'; + * + * const users = ajax({ + * url: 'https://httpbin.org/delay/2', + * method: 'POST', + * headers: { + * 'Content-Type': 'application/json', + * 'rxjs-custom-header': 'Rxjs' + * }, + * body: { + * rxjs: 'Hello World!' + * } + * }).pipe( + * map(response => console.log('response: ', response)), + * catchError(error => { + * console.log('error: ', error); + * return of(error); + * }) + * ); + * + * ``` + * + * ## Using ajax() to fetch. An error object that is being returned from the request. + * ```ts + * import { ajax } from 'rxjs/ajax'; + * import { map, catchError } from 'rxjs/operators'; + * import { of } from 'rxjs'; + * + * const obs$ = ajax(`https://api.github.com/404`).pipe( + * map(userResponse => console.log('users: ', userResponse)), + * catchError(error => { + * console.log('error: ', error); + * return of(error); + * }) + * ); + * + * ``` + */ +export const ajax: AjaxCreationMethod = (() => AjaxObservable.create)(); diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/Action.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/Action.ts new file mode 100644 index 00000000..6cf91bcb --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/Action.ts @@ -0,0 +1,36 @@ +import { Scheduler } from '../Scheduler'; +import { Subscription } from '../Subscription'; +import { SchedulerAction } from '../types'; + +/** + * A unit of work to be executed in a `scheduler`. An action is typically + * created from within a {@link SchedulerLike} and an RxJS user does not need to concern + * themselves about creating and manipulating an Action. + * + * ```ts + * class Action<T> extends Subscription { + * new (scheduler: Scheduler, work: (state?: T) => void); + * schedule(state?: T, delay: number = 0): Subscription; + * } + * ``` + * + * @class Action<T> + */ +export class Action<T> extends Subscription { + constructor(scheduler: Scheduler, work: (this: SchedulerAction<T>, state?: T) => void) { + super(); + } + /** + * Schedules this action on its parent {@link SchedulerLike} for execution. May be passed + * some context object, `state`. May happen at some point in the future, + * according to the `delay` parameter, if specified. + * @param {T} [state] Some contextual data that the `work` function uses when + * called by the Scheduler. + * @param {number} [delay] Time to wait before executing the work, where the + * time unit is implicit and defined by the Scheduler. + * @return {void} + */ + public schedule(state?: T, delay: number = 0): Subscription { + return this; + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts new file mode 100644 index 00000000..e9ea64fa --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts @@ -0,0 +1,47 @@ +import { AsyncAction } from './AsyncAction'; +import { AnimationFrameScheduler } from './AnimationFrameScheduler'; +import { SchedulerAction } from '../types'; + +/** + * We need this JSDoc comment for affecting ESDoc. + * @ignore + * @extends {Ignored} + */ +export class AnimationFrameAction<T> extends AsyncAction<T> { + + constructor(protected scheduler: AnimationFrameScheduler, + protected work: (this: SchedulerAction<T>, state?: T) => void) { + super(scheduler, work); + } + + protected requestAsyncId(scheduler: AnimationFrameScheduler, id?: any, delay: number = 0): any { + // If delay is greater than 0, request as an async action. + if (delay !== null && delay > 0) { + return super.requestAsyncId(scheduler, id, delay); + } + // Push the action to the end of the scheduler queue. + scheduler.actions.push(this); + // If an animation frame has already been requested, don't request another + // one. If an animation frame hasn't been requested yet, request one. Return + // the current animation frame request id. + return scheduler.scheduled || (scheduler.scheduled = requestAnimationFrame( + () => scheduler.flush(null))); + } + protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: any, delay: number = 0): any { + // If delay exists and is greater than 0, or if the delay is null (the + // action wasn't rescheduled) but was originally scheduled as an async + // action, then recycle as an async action. + if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) { + return super.recycleAsyncId(scheduler, id, delay); + } + // If the scheduler queue is empty, cancel the requested animation frame and + // set the scheduled flag to undefined so the next AnimationFrameAction will + // request its own. + if (scheduler.actions.length === 0) { + cancelAnimationFrame(id); + scheduler.scheduled = undefined; + } + // Return undefined so the action knows to request a new async id if it's rescheduled. + return undefined; + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts new file mode 100644 index 00000000..c550429f --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts @@ -0,0 +1,31 @@ +import { AsyncAction } from './AsyncAction'; +import { AsyncScheduler } from './AsyncScheduler'; + +export class AnimationFrameScheduler extends AsyncScheduler { + public flush(action?: AsyncAction<any>): void { + + this.active = true; + this.scheduled = undefined; + + const {actions} = this; + let error: any; + let index: number = -1; + let count: number = actions.length; + action = action || actions.shift(); + + do { + if (error = action.execute(action.state, action.delay)) { + break; + } + } while (++index < count && (action = actions.shift())); + + this.active = false; + + if (error) { + while (++index < count && (action = actions.shift())) { + action.unsubscribe(); + } + throw error; + } + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AsapAction.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AsapAction.ts new file mode 100644 index 00000000..1fe1622d --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/AsapAction.ts @@ -0,0 +1,48 @@ +import { Immediate } from '../util/Immediate'; +import { AsyncAction } from './AsyncAction'; +import { AsapScheduler } from './AsapScheduler'; +import { SchedulerAction } from '../types'; +/** + * We need this JSDoc comment for affecting ESDoc. + * @ignore + * @extends {Ignored} + */ +export class AsapAction<T> extends AsyncAction<T> { + + constructor(protected scheduler: AsapScheduler, + protected work: (this: SchedulerAction<T>, state?: T) => void) { + super(scheduler, work); + } + + protected requestAsyncId(scheduler: AsapScheduler, id?: any, delay: number = 0): any { + // If delay is greater than 0, request as an async action. + if (delay !== null && delay > 0) { + return super.requestAsyncId(scheduler, id, delay); + } + // Push the action to the end of the scheduler queue. + scheduler.actions.push(this); + // If a microtask has already been scheduled, don't schedule another + // one. If a microtask hasn't been scheduled yet, schedule one now. Return + // the current scheduled microtask id. + return scheduler.scheduled || (scheduler.scheduled = Immediate.setImmediate( + scheduler.flush.bind(scheduler, null) + )); + } + protected recycleAsyncId(scheduler: AsapScheduler, id?: any, delay: number = 0): any { + // If delay exists and is greater than 0, or if the delay is null (the + // action wasn't rescheduled) but was originally scheduled as an async + // action, then recycle as an async action. + if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) { + return super.recycleAsyncId(scheduler, id, delay); + } + // If the scheduler queue is empty, cancel the requested microtask and + // set the scheduled flag to undefined so the next AsapAction will schedule + // its own. + if (scheduler.actions.length === 0) { + Immediate.clearImmediate(id); + scheduler.scheduled = undefined; + } + // Return undefined so the action knows to request a new async id if it's rescheduled. + return undefined; + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/animationFrame.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/animationFrame.ts new file mode 100644 index 00000000..a3f62050 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/animationFrame.ts @@ -0,0 +1,40 @@ +import { AnimationFrameAction } from './AnimationFrameAction'; +import { AnimationFrameScheduler } from './AnimationFrameScheduler'; + +/** + * + * Animation Frame Scheduler + * + * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span> + * + * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler + * behaviour. + * + * Without delay, `animationFrame` scheduler can be used to create smooth browser animations. + * It makes sure scheduled task will happen just before next browser content repaint, + * thus performing animations as efficiently as possible. + * + * ## Example + * Schedule div height animation + * ```ts + * // html: <div style="background: #0ff;"></div> + * import { animationFrameScheduler } from 'rxjs'; + * + * const div = document.querySelector('div'); + * + * animationFrameScheduler.schedule(function(height) { + * div.style.height = height + "px"; + * + * this.schedule(height + 1); // `this` references currently executing Action, + * // which we reschedule with new state + * }, 0, 0); + * + * // You will see a div element growing in height + * ``` + */ +export const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction); + +/** + * @deprecated renamed. Use {@link animationFrameScheduler} + */ +export const animationFrame = animationFrameScheduler; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/asap.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/asap.ts new file mode 100644 index 00000000..bbd721d2 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/scheduler/asap.ts @@ -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; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts new file mode 100644 index 00000000..b9bd72d1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts @@ -0,0 +1,31 @@ +export interface ArgumentOutOfRangeError extends Error { +} + +export interface ArgumentOutOfRangeErrorCtor { + new(): ArgumentOutOfRangeError; +} + +const ArgumentOutOfRangeErrorImpl = (() => { + function ArgumentOutOfRangeErrorImpl(this: any) { + Error.call(this); + this.message = 'argument out of range'; + this.name = 'ArgumentOutOfRangeError'; + return this; + } + + ArgumentOutOfRangeErrorImpl.prototype = Object.create(Error.prototype); + + return ArgumentOutOfRangeErrorImpl; +})(); + +/** + * An error thrown when an element was queried at a certain index of an + * Observable, but no such index or position exists in that sequence. + * + * @see {@link elementAt} + * @see {@link take} + * @see {@link takeLast} + * + * @class ArgumentOutOfRangeError + */ +export const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor = ArgumentOutOfRangeErrorImpl as any;
\ No newline at end of file diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/applyMixins.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/applyMixins.ts new file mode 100644 index 00000000..7c1ed242 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/internal/util/applyMixins.ts @@ -0,0 +1,10 @@ +export function applyMixins(derivedCtor: any, baseCtors: any[]) { + for (let i = 0, len = baseCtors.length; i < len; i++) { + const baseCtor = baseCtors[i]; + const propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype); + for (let j = 0, len2 = propertyKeys.length; j < len2; j++) { + const name = propertyKeys[j]; + derivedCtor.prototype[name] = baseCtor.prototype[name]; + } + } +}
\ No newline at end of file diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayLikeObservable.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayLikeObservable.ts new file mode 100644 index 00000000..30da2881 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayLikeObservable.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/observable/ArrayLikeObservable'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayObservable.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayObservable.ts new file mode 100644 index 00000000..ce2da267 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/ArrayObservable.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/observable/ArrayObservable'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/AjaxObservable.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/AjaxObservable.ts new file mode 100644 index 00000000..53250600 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/AjaxObservable.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/observable/dom/AjaxObservable';
\ No newline at end of file diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/ajax.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/ajax.ts new file mode 100644 index 00000000..fd13b940 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/observable/dom/ajax.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/observable/dom/ajax';
\ No newline at end of file diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/operators/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/operators/package.json new file mode 100644 index 00000000..eefac38c --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/operators/package.json @@ -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 +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/animationFrame.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/animationFrame.ts new file mode 100644 index 00000000..f2936244 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/animationFrame.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/scheduler/animationFrame'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/asap.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/asap.ts new file mode 100644 index 00000000..934d4b55 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/scheduler/asap.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/scheduler/asap'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/testing/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/testing/package.json new file mode 100644 index 00000000..1a11a9f0 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/testing/package.json @@ -0,0 +1,8 @@ +{ + "name": "rxjs/testing", + "typings": "./index.d.ts", + "main": "./index.js", + "module": "../_esm5/testing/index.js", + "es2015": "../_esm2015/testing/index.js", + "sideEffects": false +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/tsconfig.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/tsconfig.json new file mode 100644 index 00000000..14e76219 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/tsconfig.json @@ -0,0 +1,32 @@ +{ + "compilerOptions": { + "removeComments": true, + "preserveConstEnums": true, + "sourceMap": true, + "strictFunctionTypes": true, + "noImplicitAny": true, + "noImplicitReturns": true, + "noImplicitThis": true, + "suppressImplicitAnyIndexErrors": true, + "moduleResolution": "node", + "stripInternal": false, + "target": "es5", + "outDir": "./.out", + "lib": [ + "es5", + "es2015.iterable", + "es2015.collection", + "es2015.promise", + "es2015.symbol", + "es2015.symbol.wellknown", + "dom" + ] + }, + "formatCodeOptions": { + "indentSize": 2, + "tabSize": 2 + }, + "bazelOptions": { + "suppressTsconfigOverrideWarnings": true + } +} diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/ArgumentOutOfRangeError.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/ArgumentOutOfRangeError.ts new file mode 100644 index 00000000..48e47127 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/ArgumentOutOfRangeError.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/util/ArgumentOutOfRangeError'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/applyMixins.ts b/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/applyMixins.ts new file mode 100644 index 00000000..b5ef81c4 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/util/applyMixins.ts @@ -0,0 +1 @@ +export * from 'rxjs-compat/util/applyMixins'; diff --git a/sandbox/testAppNevena/Front/node_modules/rxjs/src/webSocket/package.json b/sandbox/testAppNevena/Front/node_modules/rxjs/src/webSocket/package.json new file mode 100644 index 00000000..34020bde --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/rxjs/src/webSocket/package.json @@ -0,0 +1,8 @@ +{ + "name": "rxjs/webSocket", + "typings": "./index.d.ts", + "main": "./index.js", + "module": "../_esm5/webSocket/index.js", + "es2015": "../_esm2015/webSocket/index.js", + "sideEffects": false +} |