npm - @angular/platform-server - Versions diffs - 13.0.0-next.7 → 13.0.0-rc.1 - Mend

@angular/platform-server 13.0.0-next.7 → 13.0.0-rc.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (76) hide show

package/{esm2015/index.js → esm2020/index.mjs} +0 -0
package/{esm2015/init/index.js → esm2020/init/index.mjs} +0 -0
package/{esm2015/init/init.js → esm2020/init/init.mjs} +0 -0
package/{esm2015/init/public_api.js → esm2020/init/public_api.mjs} +0 -0
package/{esm2015/init/src/init.js → esm2020/init/src/init.mjs} +0 -0
package/{esm2015/init/src/shims.js → esm2020/init/src/shims.mjs} +0 -0
package/esm2020/platform-server.mjs +5 -0
package/{esm2015/public_api.js → esm2020/public_api.mjs} +0 -0
package/esm2020/src/domino_adapter.mjs +90 -0
package/esm2020/src/http.mjs +125 -0
package/esm2020/src/location.mjs +125 -0
package/{esm2015/src/platform-server.js → esm2020/src/platform-server.mjs} +0 -0
package/esm2020/src/platform_state.mjs +42 -0
package/{esm2015/src/private_export.js → esm2020/src/private_export.mjs} +0 -0
package/esm2020/src/server.mjs +104 -0
package/esm2020/src/server_events.mjs +39 -0
package/esm2020/src/server_renderer.mjs +273 -0
package/esm2020/src/styles_host.mjs +51 -0
package/{esm2015/src/tokens.js → esm2020/src/tokens.mjs} +0 -0
package/esm2020/src/transfer_state.mjs +53 -0
package/esm2020/src/utils.mjs +99 -0
package/{esm2015/src/version.js → esm2020/src/version.mjs} +1 -1
package/{esm2015/testing/index.js → esm2020/testing/index.mjs} +0 -0
package/{esm2015/testing/public_api.js → esm2020/testing/public_api.mjs} +0 -0
package/esm2020/testing/src/server.mjs +37 -0
package/{esm2015/testing/src/testing.js → esm2020/testing/src/testing.mjs} +0 -0
package/{esm2015/testing/testing.js → esm2020/testing/testing.mjs} +0 -0
package/fesm2015/{init.js → init.mjs} +4 -4
package/fesm2015/init.mjs.map +1 -0
package/fesm2015/platform-server.mjs +1046 -0
package/fesm2015/platform-server.mjs.map +1 -0
package/fesm2015/{testing.js → testing.mjs} +14 -9
package/fesm2015/testing.mjs.map +1 -0
package/fesm2020/init.mjs +141 -0
package/fesm2020/init.mjs.map +1 -0
package/{fesm2015/platform-server.js → fesm2020/platform-server.mjs} +117 -79
package/fesm2020/platform-server.mjs.map +1 -0
package/fesm2020/testing.mjs +75 -0
package/fesm2020/testing.mjs.map +1 -0
package/init/init.d.ts +1 -1
package/init/package.json +5 -5
package/package.json +47 -21
package/platform-server.d.ts +19 -64
package/testing/package.json +5 -5
package/testing/testing.d.ts +7 -1
package/bundles/platform-server-init.umd.js +0 -469
package/bundles/platform-server-init.umd.js.map +0 -1
package/bundles/platform-server-testing.umd.js +0 -79
package/bundles/platform-server-testing.umd.js.map +0 -1
package/bundles/platform-server.umd.js +0 -1350
package/bundles/platform-server.umd.js.map +0 -1
package/esm2015/init/init.externs.js +0 -6
package/esm2015/platform-server.externs.js +0 -6
package/esm2015/platform-server.js +0 -10
package/esm2015/src/domino_adapter.js +0 -91
package/esm2015/src/http.js +0 -122
package/esm2015/src/location.js +0 -118
package/esm2015/src/platform_state.js +0 -39
package/esm2015/src/server.js +0 -94
package/esm2015/src/server_events.js +0 -36
package/esm2015/src/server_renderer.js +0 -271
package/esm2015/src/styles_host.js +0 -44
package/esm2015/src/transfer_state.js +0 -41
package/esm2015/src/utils.js +0 -100
package/esm2015/testing/src/server.js +0 -32
package/esm2015/testing/testing.externs.js +0 -6
package/fesm2015/init.js.map +0 -1
package/fesm2015/platform-server.js.map +0 -1
package/fesm2015/testing.js.map +0 -1
package/init/init.metadata.json +0 -1
package/init.d.ts +0 -7
package/init.metadata.json +0 -1
package/platform-server.metadata.json +0 -1
package/testing/testing.metadata.json +0 -1
package/testing.d.ts +0 -7
package/testing.metadata.json +0 -1

package/{esm2015/index.js → esm2020/index.mjs} RENAMED Viewed

File without changes

package/{esm2015/init/index.js → esm2020/init/index.mjs} RENAMED Viewed

File without changes

package/{esm2015/init/init.js → esm2020/init/init.mjs} RENAMED Viewed

File without changes

package/{esm2015/init/public_api.js → esm2020/init/public_api.mjs} RENAMED Viewed

File without changes

package/{esm2015/init/src/init.js → esm2020/init/src/init.mjs} RENAMED Viewed

File without changes

package/{esm2015/init/src/shims.js → esm2020/init/src/shims.mjs} RENAMED Viewed

File without changes

package/esm2020/platform-server.mjs ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0tc2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhdGZvcm0tc2VydmVyL3BsYXRmb3JtLXNlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/{esm2015/public_api.js → esm2020/public_api.mjs} RENAMED Viewed

File without changes

package/esm2020/src/domino_adapter.mjs ADDED Viewed

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ɵsetRootDomAdapter as setRootDomAdapter } from '@angular/common';
+import { ɵBrowserDomAdapter as BrowserDomAdapter } from '@angular/platform-browser';
+import * as domino from 'domino';
+export function setDomTypes() {
+    // Make all Domino types available in the global env.
+    Object.assign(global, domino.impl);
+    global['KeyboardEvent'] = domino.impl.Event;
+}
+/**
+ * Parses a document string to a Document object.
+ */
+export function parseDocument(html, url = '/') {
+    let window = domino.createWindow(html, url);
+    let doc = window.document;
+    return doc;
+}
+/**
+ * Serializes a document to string.
+ */
+export function serializeDocument(doc) {
+    return doc.serialize();
+}
+/**
+ * DOM Adapter for the server platform based on https://github.com/fgnass/domino.
+ */
+export class DominoAdapter extends BrowserDomAdapter {
+    constructor() {
+        super(...arguments);
+        this.supportsDOMEvents = false;
+    }
+    static makeCurrent() {
+        setDomTypes();
+        setRootDomAdapter(new DominoAdapter());
+    }
+    createHtmlDocument() {
+        return parseDocument('<html><head><title>fakeTitle</title></head><body></body></html>');
+    }
+    getDefaultDocument() {
+        if (!DominoAdapter.defaultDoc) {
+            DominoAdapter.defaultDoc = domino.createDocument();
+        }
+        return DominoAdapter.defaultDoc;
+    }
+    isElementNode(node) {
+        return node ? node.nodeType === DominoAdapter.defaultDoc.ELEMENT_NODE : false;
+    }
+    isShadowRoot(node) {
+        return node.shadowRoot == node;
+    }
+    /** @deprecated No longer being used in Ivy code. To be removed in version 14. */
+    getGlobalEventTarget(doc, target) {
+        if (target === 'window') {
+            return doc.defaultView;
+        }
+        if (target === 'document') {
+            return doc;
+        }
+        if (target === 'body') {
+            return doc.body;
+        }
+        return null;
+    }
+    getBaseHref(doc) {
+        // TODO(alxhub): Need relative path logic from BrowserDomAdapter here?
+        return doc.documentElement.querySelector('base')?.getAttribute('href') || '';
+    }
+    dispatchEvent(el, evt) {
+        el.dispatchEvent(evt);
+        // Dispatch the event to the window also.
+        const doc = el.ownerDocument || el;
+        const win = doc.defaultView;
+        if (win) {
+            win.dispatchEvent(evt);
+        }
+    }
+    getUserAgent() {
+        return 'Fake user agent';
+    }
+    getCookie(name) {
+        throw new Error('getCookie has not been implemented');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/http.mjs ADDED Viewed

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { PlatformLocation, XhrFactory } from '@angular/common';
+import { HttpBackend, HttpHandler, ɵHttpInterceptingHandler as HttpInterceptingHandler } from '@angular/common/http';
+import { Injectable, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as xhr2 from 'xhr2';
+import { INITIAL_CONFIG } from './tokens';
+import * as i0 from "@angular/core";
+// @see https://www.w3.org/Protocols/HTTP/1.1/draft-ietf-http-v11-spec-01#URI-syntax
+const isAbsoluteUrl = /^[a-zA-Z\-\+.]+:\/\//;
+export class ServerXhr {
+    build() {
+        return new xhr2.XMLHttpRequest();
+    }
+}
+ServerXhr.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerXhr, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ServerXhr.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerXhr });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerXhr, decorators: [{
+            type: Injectable
+        }] });
+export class ZoneMacroTaskWrapper {
+    wrap(request) {
+        return new Observable((observer) => {
+            let task = null;
+            let scheduled = false;
+            let sub = null;
+            let savedResult = null;
+            let savedError = null;
+            const scheduleTask = (_task) => {
+                task = _task;
+                scheduled = true;
+                const delegate = this.delegate(request);
+                sub = delegate.subscribe(res => savedResult = res, err => {
+                    if (!scheduled) {
+                        throw new Error('An http observable was completed twice. This shouldn\'t happen, please file a bug.');
+                    }
+                    savedError = err;
+                    scheduled = false;
+                    task.invoke();
+                }, () => {
+                    if (!scheduled) {
+                        throw new Error('An http observable was completed twice. This shouldn\'t happen, please file a bug.');
+                    }
+                    scheduled = false;
+                    task.invoke();
+                });
+            };
+            const cancelTask = (_task) => {
+                if (!scheduled) {
+                    return;
+                }
+                scheduled = false;
+                if (sub) {
+                    sub.unsubscribe();
+                    sub = null;
+                }
+            };
+            const onComplete = () => {
+                if (savedError !== null) {
+                    observer.error(savedError);
+                }
+                else {
+                    observer.next(savedResult);
+                    observer.complete();
+                }
+            };
+            // MockBackend for Http is synchronous, which means that if scheduleTask is by
+            // scheduleMacroTask, the request will hit MockBackend and the response will be
+            // sent, causing task.invoke() to be called.
+            const _task = Zone.current.scheduleMacroTask('ZoneMacroTaskWrapper.subscribe', onComplete, {}, () => null, cancelTask);
+            scheduleTask(_task);
+            return () => {
+                if (scheduled && task) {
+                    task.zone.cancelTask(task);
+                    scheduled = false;
+                }
+                if (sub) {
+                    sub.unsubscribe();
+                    sub = null;
+                }
+            };
+        });
+    }
+}
+export class ZoneClientBackend extends ZoneMacroTaskWrapper {
+    constructor(backend, platformLocation, config) {
+        super();
+        this.backend = backend;
+        this.platformLocation = platformLocation;
+        this.config = config;
+    }
+    handle(request) {
+        const { href, protocol, hostname, port } = this.platformLocation;
+        if (this.config.useAbsoluteUrl && !isAbsoluteUrl.test(request.url) &&
+            isAbsoluteUrl.test(href)) {
+            const baseHref = this.platformLocation.getBaseHrefFromDOM() || href;
+            const urlPrefix = `${protocol}//${hostname}` + (port ? `:${port}` : '');
+            const baseUrl = new URL(baseHref, urlPrefix);
+            const url = new URL(request.url, baseUrl);
+            return this.wrap(request.clone({ url: url.toString() }));
+        }
+        return this.wrap(request);
+    }
+    delegate(request) {
+        return this.backend.handle(request);
+    }
+}
+export function zoneWrappedInterceptingHandler(backend, injector, platformLocation, config) {
+    const realBackend = new HttpInterceptingHandler(backend, injector);
+    return new ZoneClientBackend(realBackend, platformLocation, config);
+}
+export const SERVER_HTTP_PROVIDERS = [
+    { provide: XhrFactory, useClass: ServerXhr }, {
+        provide: HttpHandler,
+        useFactory: zoneWrappedInterceptingHandler,
+        deps: [HttpBackend, Injector, PlatformLocation, INITIAL_CONFIG]
+    }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../../../../packages/platform-server/src/http.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {PlatformLocation, XhrFactory} from '@angular/common';\nimport {HttpBackend, HttpEvent, HttpHandler, HttpRequest, ɵHttpInterceptingHandler as HttpInterceptingHandler} from '@angular/common/http';\nimport {Injectable, Injector, Provider} from '@angular/core';\nimport {Observable, Observer, Subscription} from 'rxjs';\nimport * as xhr2 from 'xhr2';\n\nimport {INITIAL_CONFIG, PlatformConfig} from './tokens';\n\n// @see https://www.w3.org/Protocols/HTTP/1.1/draft-ietf-http-v11-spec-01#URI-syntax\nconst isAbsoluteUrl = /^[a-zA-Z\\-\\+.]+:\\/\\//;\n\n@Injectable()\nexport class ServerXhr implements XhrFactory {\n  build(): XMLHttpRequest {\n    return new xhr2.XMLHttpRequest();\n  }\n}\n\nexport abstract class ZoneMacroTaskWrapper<S, R> {\n  wrap(request: S): Observable<R> {\n    return new Observable((observer: Observer<R>) => {\n      let task: Task = null!;\n      let scheduled: boolean = false;\n      let sub: Subscription|null = null;\n      let savedResult: any = null;\n      let savedError: any = null;\n\n      const scheduleTask = (_task: Task) => {\n        task = _task;\n        scheduled = true;\n\n        const delegate = this.delegate(request);\n        sub = delegate.subscribe(\n            res => savedResult = res,\n            err => {\n              if (!scheduled) {\n                throw new Error(\n                    'An http observable was completed twice. This shouldn\\'t happen, please file a bug.');\n              }\n              savedError = err;\n              scheduled = false;\n              task.invoke();\n            },\n            () => {\n              if (!scheduled) {\n                throw new Error(\n                    'An http observable was completed twice. This shouldn\\'t happen, please file a bug.');\n              }\n              scheduled = false;\n              task.invoke();\n            });\n      };\n\n      const cancelTask = (_task: Task) => {\n        if (!scheduled) {\n          return;\n        }\n        scheduled = false;\n        if (sub) {\n          sub.unsubscribe();\n          sub = null;\n        }\n      };\n\n      const onComplete = () => {\n        if (savedError !== null) {\n          observer.error(savedError);\n        } else {\n          observer.next(savedResult);\n          observer.complete();\n        }\n      };\n\n      // MockBackend for Http is synchronous, which means that if scheduleTask is by\n      // scheduleMacroTask, the request will hit MockBackend and the response will be\n      // sent, causing task.invoke() to be called.\n      const _task = Zone.current.scheduleMacroTask(\n          'ZoneMacroTaskWrapper.subscribe', onComplete, {}, () => null, cancelTask);\n      scheduleTask(_task);\n\n      return () => {\n        if (scheduled && task) {\n          task.zone.cancelTask(task);\n          scheduled = false;\n        }\n        if (sub) {\n          sub.unsubscribe();\n          sub = null;\n        }\n      };\n    });\n  }\n\n  protected abstract delegate(request: S): Observable<R>;\n}\n\nexport class ZoneClientBackend extends\n    ZoneMacroTaskWrapper<HttpRequest<any>, HttpEvent<any>> implements HttpBackend {\n  constructor(\n      private backend: HttpBackend, private platformLocation: PlatformLocation,\n      private config: PlatformConfig) {\n    super();\n  }\n\n  handle(request: HttpRequest<any>): Observable<HttpEvent<any>> {\n    const {href, protocol, hostname, port} = this.platformLocation;\n    if (this.config.useAbsoluteUrl && !isAbsoluteUrl.test(request.url) &&\n        isAbsoluteUrl.test(href)) {\n      const baseHref = this.platformLocation.getBaseHrefFromDOM() || href;\n      const urlPrefix = `${protocol}//${hostname}` + (port ? `:${port}` : '');\n      const baseUrl = new URL(baseHref, urlPrefix);\n      const url = new URL(request.url, baseUrl);\n      return this.wrap(request.clone({url: url.toString()}));\n    }\n    return this.wrap(request);\n  }\n\n  protected override delegate(request: HttpRequest<any>): Observable<HttpEvent<any>> {\n    return this.backend.handle(request);\n  }\n}\n\nexport function zoneWrappedInterceptingHandler(\n    backend: HttpBackend, injector: Injector, platformLocation: PlatformLocation,\n    config: PlatformConfig) {\n  const realBackend: HttpBackend = new HttpInterceptingHandler(backend, injector);\n  return new ZoneClientBackend(realBackend, platformLocation, config);\n}\n\nexport const SERVER_HTTP_PROVIDERS: Provider[] = [\n  {provide: XhrFactory, useClass: ServerXhr}, {\n    provide: HttpHandler,\n    useFactory: zoneWrappedInterceptingHandler,\n    deps: [HttpBackend, Injector, PlatformLocation, INITIAL_CONFIG]\n  }\n];\n"]}

package/esm2020/src/location.mjs ADDED Viewed

@@ -0,0 +1,125 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DOCUMENT, ɵgetDOM as getDOM } from '@angular/common';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as url from 'url';
+import { INITIAL_CONFIG } from './tokens';
+import * as i0 from "@angular/core";
+function parseUrl(urlStr) {
+    const parsedUrl = url.parse(urlStr);
+    return {
+        hostname: parsedUrl.hostname || '',
+        protocol: parsedUrl.protocol || '',
+        port: parsedUrl.port || '',
+        pathname: parsedUrl.pathname || '',
+        search: parsedUrl.search || '',
+        hash: parsedUrl.hash || '',
+    };
+}
+/**
+ * Server-side implementation of URL state. Implements `pathname`, `search`, and `hash`
+ * but not the state stack.
+ */
+export class ServerPlatformLocation {
+    constructor(_doc, _config) {
+        this._doc = _doc;
+        this.href = '/';
+        this.hostname = '/';
+        this.protocol = '/';
+        this.port = '/';
+        this.pathname = '/';
+        this.search = '';
+        this.hash = '';
+        this._hashUpdate = new Subject();
+        const config = _config;
+        if (!config) {
+            return;
+        }
+        if (config.url) {
+            const url = parseUrl(config.url);
+            this.protocol = url.protocol;
+            this.hostname = url.hostname;
+            this.port = url.port;
+            this.pathname = url.pathname;
+            this.search = url.search;
+            this.hash = url.hash;
+            this.href = _doc.location.href;
+        }
+        if (config.useAbsoluteUrl) {
+            if (!config.baseUrl) {
+                throw new Error(`"PlatformConfig.baseUrl" must be set if "useAbsoluteUrl" is true`);
+            }
+            const url = parseUrl(config.baseUrl);
+            this.protocol = url.protocol;
+            this.hostname = url.hostname;
+            this.port = url.port;
+        }
+    }
+    getBaseHrefFromDOM() {
+        return getDOM().getBaseHref(this._doc);
+    }
+    onPopState(fn) {
+        // No-op: a state stack is not implemented, so
+        // no events will ever come.
+        return () => { };
+    }
+    onHashChange(fn) {
+        const subscription = this._hashUpdate.subscribe(fn);
+        return () => subscription.unsubscribe();
+    }
+    get url() {
+        return `${this.pathname}${this.search}${this.hash}`;
+    }
+    setHash(value, oldUrl) {
+        if (this.hash === value) {
+            // Don't fire events if the hash has not changed.
+            return;
+        }
+        this.hash = value;
+        const newUrl = this.url;
+        scheduleMicroTask(() => this._hashUpdate.next({ type: 'hashchange', state: null, oldUrl, newUrl }));
+    }
+    replaceState(state, title, newUrl) {
+        const oldUrl = this.url;
+        const parsedUrl = parseUrl(newUrl);
+        this.pathname = parsedUrl.pathname;
+        this.search = parsedUrl.search;
+        this.setHash(parsedUrl.hash, oldUrl);
+    }
+    pushState(state, title, newUrl) {
+        this.replaceState(state, title, newUrl);
+    }
+    forward() {
+        throw new Error('Not implemented');
+    }
+    back() {
+        throw new Error('Not implemented');
+    }
+    // History API isn't available on server, therefore return undefined
+    getState() {
+        return undefined;
+    }
+}
+ServerPlatformLocation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerPlatformLocation, deps: [{ token: DOCUMENT }, { token: INITIAL_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ServerPlatformLocation.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerPlatformLocation });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerPlatformLocation, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INITIAL_CONFIG]
+                }] }]; } });
+export function scheduleMicroTask(fn) {
+    Zone.current.scheduleMicroTask('scheduleMicrotask', fn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.js","sourceRoot":"","sources":["../../../../../../packages/platform-server/src/location.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {DOCUMENT, LocationChangeEvent, LocationChangeListener, PlatformLocation, ɵgetDOM as getDOM} from '@angular/common';\nimport {Inject, Injectable, Optional} from '@angular/core';\nimport {Subject} from 'rxjs';\nimport * as url from 'url';\nimport {INITIAL_CONFIG, PlatformConfig} from './tokens';\n\nfunction parseUrl(urlStr: string) {\n  const parsedUrl = url.parse(urlStr);\n  return {\n    hostname: parsedUrl.hostname || '',\n    protocol: parsedUrl.protocol || '',\n    port: parsedUrl.port || '',\n    pathname: parsedUrl.pathname || '',\n    search: parsedUrl.search || '',\n    hash: parsedUrl.hash || '',\n  };\n}\n\n/**\n * Server-side implementation of URL state. Implements `pathname`, `search`, and `hash`\n * but not the state stack.\n */\n@Injectable()\nexport class ServerPlatformLocation implements PlatformLocation {\n  public readonly href: string = '/';\n  public readonly hostname: string = '/';\n  public readonly protocol: string = '/';\n  public readonly port: string = '/';\n  public readonly pathname: string = '/';\n  public readonly search: string = '';\n  public readonly hash: string = '';\n  private _hashUpdate = new Subject<LocationChangeEvent>();\n\n  constructor(\n      @Inject(DOCUMENT) private _doc: any, @Optional() @Inject(INITIAL_CONFIG) _config: any) {\n    const config = _config as PlatformConfig | null;\n    if (!config) {\n      return;\n    }\n    if (config.url) {\n      const url = parseUrl(config.url);\n      this.protocol = url.protocol;\n      this.hostname = url.hostname;\n      this.port = url.port;\n      this.pathname = url.pathname;\n      this.search = url.search;\n      this.hash = url.hash;\n      this.href = _doc.location.href;\n    }\n    if (config.useAbsoluteUrl) {\n      if (!config.baseUrl) {\n        throw new Error(`\"PlatformConfig.baseUrl\" must be set if \"useAbsoluteUrl\" is true`);\n      }\n      const url = parseUrl(config.baseUrl);\n      this.protocol = url.protocol;\n      this.hostname = url.hostname;\n      this.port = url.port;\n    }\n  }\n\n  getBaseHrefFromDOM(): string {\n    return getDOM().getBaseHref(this._doc)!;\n  }\n\n  onPopState(fn: LocationChangeListener): VoidFunction {\n    // No-op: a state stack is not implemented, so\n    // no events will ever come.\n    return () => {};\n  }\n\n  onHashChange(fn: LocationChangeListener): VoidFunction {\n    const subscription = this._hashUpdate.subscribe(fn);\n    return () => subscription.unsubscribe();\n  }\n\n  get url(): string {\n    return `${this.pathname}${this.search}${this.hash}`;\n  }\n\n  private setHash(value: string, oldUrl: string) {\n    if (this.hash === value) {\n      // Don't fire events if the hash has not changed.\n      return;\n    }\n    (this as {hash: string}).hash = value;\n    const newUrl = this.url;\n    scheduleMicroTask(\n        () => this._hashUpdate.next(\n            {type: 'hashchange', state: null, oldUrl, newUrl} as LocationChangeEvent));\n  }\n\n  replaceState(state: any, title: string, newUrl: string): void {\n    const oldUrl = this.url;\n    const parsedUrl = parseUrl(newUrl);\n    (this as {pathname: string}).pathname = parsedUrl.pathname;\n    (this as {search: string}).search = parsedUrl.search;\n    this.setHash(parsedUrl.hash, oldUrl);\n  }\n\n  pushState(state: any, title: string, newUrl: string): void {\n    this.replaceState(state, title, newUrl);\n  }\n\n  forward(): void {\n    throw new Error('Not implemented');\n  }\n\n  back(): void {\n    throw new Error('Not implemented');\n  }\n\n  // History API isn't available on server, therefore return undefined\n  getState(): unknown {\n    return undefined;\n  }\n}\n\nexport function scheduleMicroTask(fn: Function) {\n  Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n}\n"]}

package/{esm2015/src/platform-server.js → esm2020/src/platform-server.mjs} RENAMED Viewed

File without changes

package/esm2020/src/platform_state.mjs ADDED Viewed

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { serializeDocument } from './domino_adapter';
+import * as i0 from "@angular/core";
+/**
+ * Representation of the current platform state.
+ *
+ * @publicApi
+ */
+export class PlatformState {
+    constructor(_doc) {
+        this._doc = _doc;
+    }
+    /**
+     * Renders the current state of the platform to string.
+     */
+    renderToString() {
+        return serializeDocument(this._doc);
+    }
+    /**
+     * Returns the current DOM state.
+     */
+    getDocument() {
+        return this._doc;
+    }
+}
+PlatformState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: PlatformState, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+PlatformState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: PlatformState });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: PlatformState, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm1fc3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGF0Zm9ybS1zZXJ2ZXIvc3JjL3BsYXRmb3JtX3N0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QyxPQUFPLEVBQUMsTUFBTSxFQUFFLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUVqRCxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQzs7QUFFbkQ7Ozs7R0FJRztBQUVILE1BQU0sT0FBTyxhQUFhO0lBQ3hCLFlBQXNDLElBQVM7UUFBVCxTQUFJLEdBQUosSUFBSSxDQUFLO0lBQUcsQ0FBQztJQUVuRDs7T0FFRztJQUNILGNBQWM7UUFDWixPQUFPLGlCQUFpQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxXQUFXO1FBQ1QsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ25CLENBQUM7O3FIQWZVLGFBQWEsa0JBQ0osUUFBUTt5SEFEakIsYUFBYTtzR0FBYixhQUFhO2tCQUR6QixVQUFVOzswQkFFSSxNQUFNOzJCQUFDLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtET0NVTUVOVH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHtzZXJpYWxpemVEb2N1bWVudH0gZnJvbSAnLi9kb21pbm9fYWRhcHRlcic7XG5cbi8qKlxuICogUmVwcmVzZW50YXRpb24gb2YgdGhlIGN1cnJlbnQgcGxhdGZvcm0gc3RhdGUuXG4gKlxuICogQHB1YmxpY0FwaVxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgUGxhdGZvcm1TdGF0ZSB7XG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoRE9DVU1FTlQpIHByaXZhdGUgX2RvYzogYW55KSB7fVxuXG4gIC8qKlxuICAgKiBSZW5kZXJzIHRoZSBjdXJyZW50IHN0YXRlIG9mIHRoZSBwbGF0Zm9ybSB0byBzdHJpbmcuXG4gICAqL1xuICByZW5kZXJUb1N0cmluZygpOiBzdHJpbmcge1xuICAgIHJldHVybiBzZXJpYWxpemVEb2N1bWVudCh0aGlzLl9kb2MpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgdGhlIGN1cnJlbnQgRE9NIHN0YXRlLlxuICAgKi9cbiAgZ2V0RG9jdW1lbnQoKTogYW55IHtcbiAgICByZXR1cm4gdGhpcy5fZG9jO1xuICB9XG59XG4iXX0=

package/{esm2015/src/private_export.js → esm2020/src/private_export.mjs} RENAMED Viewed

File without changes

package/esm2020/src/server.mjs ADDED Viewed

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ɵAnimationEngine } from '@angular/animations/browser';
+import { DOCUMENT, PlatformLocation, ViewportScroller, ɵgetDOM as getDOM, ɵNullViewportScroller as NullViewportScroller, ɵPLATFORM_SERVER_ID as PLATFORM_SERVER_ID } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { createPlatformFactory, Injector, NgModule, NgZone, Optional, PLATFORM_ID, PLATFORM_INITIALIZER, platformCore, RendererFactory2, Testability, ɵALLOW_MULTIPLE_PLATFORMS as ALLOW_MULTIPLE_PLATFORMS, ɵsetDocument } from '@angular/core';
+import { BrowserModule, EVENT_MANAGER_PLUGINS, ɵSharedStylesHost as SharedStylesHost } from '@angular/platform-browser';
+import { ɵplatformCoreDynamic as platformCoreDynamic } from '@angular/platform-browser-dynamic';
+import { NoopAnimationsModule, ɵAnimationRendererFactory } from '@angular/platform-browser/animations';
+import { DominoAdapter, parseDocument } from './domino_adapter';
+import { SERVER_HTTP_PROVIDERS } from './http';
+import { ServerPlatformLocation } from './location';
+import { PlatformState } from './platform_state';
+import { ServerEventManagerPlugin } from './server_events';
+import { ServerRendererFactory2 } from './server_renderer';
+import { ServerStylesHost } from './styles_host';
+import { INITIAL_CONFIG } from './tokens';
+import * as i0 from "@angular/core";
+function notSupported(feature) {
+    throw new Error(`platform-server does not support '${feature}'.`);
+}
+export const INTERNAL_SERVER_PLATFORM_PROVIDERS = [
+    { provide: DOCUMENT, useFactory: _document, deps: [Injector] },
+    { provide: PLATFORM_ID, useValue: PLATFORM_SERVER_ID },
+    { provide: PLATFORM_INITIALIZER, useFactory: initDominoAdapter, multi: true, deps: [Injector] }, {
+        provide: PlatformLocation,
+        useClass: ServerPlatformLocation,
+        deps: [DOCUMENT, [Optional, INITIAL_CONFIG]]
+    },
+    { provide: PlatformState, deps: [DOCUMENT] },
+    // Add special provider that allows multiple instances of platformServer* to be created.
+    { provide: ALLOW_MULTIPLE_PLATFORMS, useValue: true }
+];
+function initDominoAdapter(injector) {
+    return () => {
+        DominoAdapter.makeCurrent();
+    };
+}
+export function instantiateServerRendererFactory(renderer, engine, zone) {
+    return new ɵAnimationRendererFactory(renderer, engine, zone);
+}
+export const SERVER_RENDER_PROVIDERS = [
+    ServerRendererFactory2,
+    {
+        provide: RendererFactory2,
+        useFactory: instantiateServerRendererFactory,
+        deps: [ServerRendererFactory2, ɵAnimationEngine, NgZone]
+    },
+    ServerStylesHost,
+    { provide: SharedStylesHost, useExisting: ServerStylesHost },
+    { provide: EVENT_MANAGER_PLUGINS, multi: true, useClass: ServerEventManagerPlugin },
+];
+/**
+ * The ng module for the server.
+ *
+ * @publicApi
+ */
+export class ServerModule {
+}
+ServerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ServerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerModule, imports: [HttpClientModule, NoopAnimationsModule], exports: [BrowserModule] });
+ServerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerModule, providers: [
+        SERVER_RENDER_PROVIDERS,
+        SERVER_HTTP_PROVIDERS,
+        { provide: Testability, useValue: null },
+        { provide: ViewportScroller, useClass: NullViewportScroller },
+    ], imports: [[HttpClientModule, NoopAnimationsModule], BrowserModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BrowserModule],
+                    imports: [HttpClientModule, NoopAnimationsModule],
+                    providers: [
+                        SERVER_RENDER_PROVIDERS,
+                        SERVER_HTTP_PROVIDERS,
+                        { provide: Testability, useValue: null },
+                        { provide: ViewportScroller, useClass: NullViewportScroller },
+                    ],
+                }]
+        }] });
+function _document(injector) {
+    let config = injector.get(INITIAL_CONFIG, null);
+    const document = config && config.document ? parseDocument(config.document, config.url) :
+        getDOM().createHtmlDocument();
+    // Tell ivy about the global document
+    ɵsetDocument(document);
+    return document;
+}
+/**
+ * @publicApi
+ */
+export const platformServer = createPlatformFactory(platformCore, 'server', INTERNAL_SERVER_PLATFORM_PROVIDERS);
+/**
+ * The server platform that supports the runtime compiler.
+ *
+ * @publicApi
+ */
+export const platformDynamicServer = createPlatformFactory(platformCoreDynamic, 'serverDynamic', INTERNAL_SERVER_PLATFORM_PROVIDERS);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../../../../packages/platform-server/src/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ɵAnimationEngine} from '@angular/animations/browser';\nimport {DOCUMENT, PlatformLocation, ViewportScroller, ɵgetDOM as getDOM, ɵNullViewportScroller as NullViewportScroller, ɵPLATFORM_SERVER_ID as PLATFORM_SERVER_ID} from '@angular/common';\nimport {HttpClientModule} from '@angular/common/http';\nimport {createPlatformFactory, Injector, NgModule, NgZone, Optional, PLATFORM_ID, PLATFORM_INITIALIZER, platformCore, PlatformRef, Provider, RendererFactory2, StaticProvider, Testability, ɵALLOW_MULTIPLE_PLATFORMS as ALLOW_MULTIPLE_PLATFORMS, ɵsetDocument} from '@angular/core';\nimport {BrowserModule, EVENT_MANAGER_PLUGINS, ɵSharedStylesHost as SharedStylesHost} from '@angular/platform-browser';\nimport {ɵplatformCoreDynamic as platformCoreDynamic} from '@angular/platform-browser-dynamic';\nimport {NoopAnimationsModule, ɵAnimationRendererFactory} from '@angular/platform-browser/animations';\n\nimport {DominoAdapter, parseDocument} from './domino_adapter';\nimport {SERVER_HTTP_PROVIDERS} from './http';\nimport {ServerPlatformLocation} from './location';\nimport {PlatformState} from './platform_state';\nimport {ServerEventManagerPlugin} from './server_events';\nimport {ServerRendererFactory2} from './server_renderer';\nimport {ServerStylesHost} from './styles_host';\nimport {INITIAL_CONFIG, PlatformConfig} from './tokens';\n\nfunction notSupported(feature: string): Error {\n  throw new Error(`platform-server does not support '${feature}'.`);\n}\n\nexport const INTERNAL_SERVER_PLATFORM_PROVIDERS: StaticProvider[] = [\n  {provide: DOCUMENT, useFactory: _document, deps: [Injector]},\n  {provide: PLATFORM_ID, useValue: PLATFORM_SERVER_ID},\n  {provide: PLATFORM_INITIALIZER, useFactory: initDominoAdapter, multi: true, deps: [Injector]}, {\n    provide: PlatformLocation,\n    useClass: ServerPlatformLocation,\n    deps: [DOCUMENT, [Optional, INITIAL_CONFIG]]\n  },\n  {provide: PlatformState, deps: [DOCUMENT]},\n  // Add special provider that allows multiple instances of platformServer* to be created.\n  {provide: ALLOW_MULTIPLE_PLATFORMS, useValue: true}\n];\n\nfunction initDominoAdapter(injector: Injector) {\n  return () => {\n    DominoAdapter.makeCurrent();\n  };\n}\n\nexport function instantiateServerRendererFactory(\n    renderer: RendererFactory2, engine: ɵAnimationEngine, zone: NgZone) {\n  return new ɵAnimationRendererFactory(renderer, engine, zone);\n}\n\nexport const SERVER_RENDER_PROVIDERS: Provider[] = [\n  ServerRendererFactory2,\n  {\n    provide: RendererFactory2,\n    useFactory: instantiateServerRendererFactory,\n    deps: [ServerRendererFactory2, ɵAnimationEngine, NgZone]\n  },\n  ServerStylesHost,\n  {provide: SharedStylesHost, useExisting: ServerStylesHost},\n  {provide: EVENT_MANAGER_PLUGINS, multi: true, useClass: ServerEventManagerPlugin},\n];\n\n/**\n * The ng module for the server.\n *\n * @publicApi\n */\n@NgModule({\n  exports: [BrowserModule],\n  imports: [HttpClientModule, NoopAnimationsModule],\n  providers: [\n    SERVER_RENDER_PROVIDERS,\n    SERVER_HTTP_PROVIDERS,\n    {provide: Testability, useValue: null},\n    {provide: ViewportScroller, useClass: NullViewportScroller},\n  ],\n})\nexport class ServerModule {\n}\n\nfunction _document(injector: Injector) {\n  let config: PlatformConfig|null = injector.get(INITIAL_CONFIG, null);\n  const document = config && config.document ? parseDocument(config.document, config.url) :\n                                               getDOM().createHtmlDocument();\n  // Tell ivy about the global document\n  ɵsetDocument(document);\n  return document;\n}\n\n/**\n * @publicApi\n */\nexport const platformServer: (extraProviders?: StaticProvider[]|undefined) => PlatformRef =\n    createPlatformFactory(platformCore, 'server', INTERNAL_SERVER_PLATFORM_PROVIDERS);\n\n/**\n * The server platform that supports the runtime compiler.\n *\n * @publicApi\n */\nexport const platformDynamicServer =\n    createPlatformFactory(platformCoreDynamic, 'serverDynamic', INTERNAL_SERVER_PLATFORM_PROVIDERS);\n"]}

package/esm2020/src/server_events.mjs ADDED Viewed

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DOCUMENT, ɵgetDOM as getDOM } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ServerEventManagerPlugin /* extends EventManagerPlugin which is private */ {
+    constructor(doc) {
+        this.doc = doc;
+    }
+    // Handle all events on the server.
+    supports(eventName) {
+        return true;
+    }
+    addEventListener(element, eventName, handler) {
+        return getDOM().onAndCancel(element, eventName, handler);
+    }
+    /** @deprecated No longer being used in Ivy code. To be removed in version 14. */
+    addGlobalEventListener(element, eventName, handler) {
+        const target = getDOM().getGlobalEventTarget(this.doc, element);
+        if (!target) {
+            throw new Error(`Unsupported event target ${target} for event ${eventName}`);
+        }
+        return this.addEventListener(target, eventName, handler);
+    }
+}
+ServerEventManagerPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerEventManagerPlugin /* extends EventManagerPlugin which is private */, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+ServerEventManagerPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerEventManagerPlugin /* extends EventManagerPlugin which is private */ });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: ServerEventManagerPlugin /* extends EventManagerPlugin which is private */, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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