npm - @angular/common - Versions diffs - 14.2.0-next.1 → 14.2.1 - Mend

@angular/common 14.2.0-next.1 → 14.2.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 (72) hide show

package/esm2020/http/src/client.mjs +4 -4
package/esm2020/http/src/interceptor.mjs +3 -3
package/esm2020/http/src/jsonp.mjs +7 -7
package/esm2020/http/src/module.mjs +15 -15
package/esm2020/http/src/xhr.mjs +3 -3
package/esm2020/http/src/xsrf.mjs +7 -7
package/esm2020/http/testing/src/backend.mjs +3 -3
package/esm2020/http/testing/src/module.mjs +4 -4
package/esm2020/src/common.mjs +2 -1
package/esm2020/src/common_module.mjs +4 -4
package/esm2020/src/directives/ng_class.mjs +3 -3
package/esm2020/src/directives/ng_component_outlet.mjs +3 -3
package/esm2020/src/directives/ng_for_of.mjs +3 -3
package/esm2020/src/directives/ng_if.mjs +3 -3
package/esm2020/src/directives/ng_optimized_image/asserts.mjs +20 -0
package/esm2020/src/directives/ng_optimized_image/error_helper.mjs +13 -0
package/esm2020/src/directives/ng_optimized_image/image_loaders/cloudflare_loader.mjs +35 -0
package/esm2020/src/directives/ng_optimized_image/image_loaders/cloudinary_loader.mjs +43 -0
package/esm2020/src/directives/ng_optimized_image/image_loaders/image_loader.mjs +79 -0
package/esm2020/src/directives/ng_optimized_image/image_loaders/imagekit_loader.mjs +35 -0
package/esm2020/src/directives/ng_optimized_image/image_loaders/imgix_loader.mjs +33 -0
package/esm2020/src/directives/ng_optimized_image/index.mjs +16 -0
package/esm2020/src/directives/ng_optimized_image/lcp_image_observer.mjs +99 -0
package/esm2020/src/directives/ng_optimized_image/ng_optimized_image.mjs +559 -0
package/esm2020/src/directives/ng_optimized_image/preconnect_link_checker.mjs +138 -0
package/esm2020/src/directives/ng_optimized_image/url.mjs +42 -0
package/esm2020/src/directives/ng_plural.mjs +7 -7
package/esm2020/src/directives/ng_style.mjs +3 -3
package/esm2020/src/directives/ng_switch.mjs +10 -10
package/esm2020/src/directives/ng_template_outlet.mjs +3 -3
package/esm2020/src/errors.mjs +1 -1
package/esm2020/src/i18n/localization.mjs +6 -6
package/esm2020/src/location/hash_location_strategy.mjs +3 -3
package/esm2020/src/location/location.mjs +4 -4
package/esm2020/src/location/location_strategy.mjs +6 -6
package/esm2020/src/location/platform_location.mjs +6 -6
package/esm2020/src/pipes/async_pipe.mjs +3 -3
package/esm2020/src/pipes/case_conversion_pipes.mjs +9 -9
package/esm2020/src/pipes/date_pipe.mjs +3 -3
package/esm2020/src/pipes/i18n_plural_pipe.mjs +3 -3
package/esm2020/src/pipes/i18n_select_pipe.mjs +3 -3
package/esm2020/src/pipes/json_pipe.mjs +3 -3
package/esm2020/src/pipes/keyvalue_pipe.mjs +3 -3
package/esm2020/src/pipes/number_pipe.mjs +9 -9
package/esm2020/src/pipes/slice_pipe.mjs +3 -3
package/esm2020/src/version.mjs +1 -1
package/esm2020/testing/src/location_mock.mjs +3 -3
package/esm2020/testing/src/mock_location_strategy.mjs +3 -3
package/esm2020/testing/src/mock_platform_location.mjs +5 -5
package/esm2020/upgrade/src/location_upgrade_module.mjs +4 -4
package/fesm2015/common.mjs +1184 -104
package/fesm2015/common.mjs.map +1 -1
package/fesm2015/http/testing.mjs +8 -8
package/fesm2015/http.mjs +37 -37
package/fesm2015/http.mjs.map +1 -1
package/fesm2015/testing.mjs +11 -11
package/fesm2015/testing.mjs.map +1 -1
package/fesm2015/upgrade.mjs +5 -5
package/fesm2020/common.mjs +1182 -104
package/fesm2020/common.mjs.map +1 -1
package/fesm2020/http/testing.mjs +8 -8
package/fesm2020/http.mjs +37 -37
package/fesm2020/http.mjs.map +1 -1
package/fesm2020/testing.mjs +11 -11
package/fesm2020/testing.mjs.map +1 -1
package/fesm2020/upgrade.mjs +5 -5
package/http/index.d.ts +72 -69
package/http/testing/index.d.ts +1 -1
package/index.d.ts +308 -1
package/package.json +2 -2
package/testing/index.d.ts +1 -1
package/upgrade/index.d.ts +1 -1

package/esm2020/src/directives/ng_optimized_image/image_loaders/cloudinary_loader.mjs ADDED Viewed

@@ -0,0 +1,43 @@
+/**
+ * @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 { createImageLoader } from './image_loader';
+/**
+ * Function that generates an ImageLoader for Cloudinary and turns it into an Angular provider.
+ *
+ * @param path Base URL of your Cloudinary images
+ * This URL should match one of the following formats:
+ * https://res.cloudinary.com/mysite
+ * https://mysite.cloudinary.com
+ * https://subdomain.mysite.com
+ * @param options An object with extra configuration:
+ * - `ensurePreconnect`: boolean flag indicating whether the NgOptimizedImage directive
+ *                       should verify that there is a corresponding `<link rel="preconnect">`
+ *                       present in the document's `<head>`.
+ * @returns Set of providers to configure the Cloudinary loader.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export const provideCloudinaryLoader = createImageLoader(createCloudinaryUrl, ngDevMode ?
+    [
+        'https://res.cloudinary.com/mysite', 'https://mysite.cloudinary.com',
+        'https://subdomain.mysite.com'
+    ] :
+    undefined);
+function createCloudinaryUrl(path, config) {
+    // Cloudinary image URLformat:
+    // https://cloudinary.com/documentation/image_transformations#transformation_url_structure
+    // Example of a Cloudinary image URL:
+    // https://res.cloudinary.com/mysite/image/upload/c_scale,f_auto,q_auto,w_600/marketing/tile-topics-m.png
+    let params = `f_auto,q_auto`; // sets image format and quality to "auto"
+    if (config.width) {
+        params += `,w_${config.width}`;
+    }
+    return `${path}/image/upload/${params}/${config.src}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/directives/ng_optimized_image/image_loaders/image_loader.mjs ADDED Viewed

@@ -0,0 +1,79 @@
+/**
+ * @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 { InjectionToken, ɵRuntimeError as RuntimeError } from '@angular/core';
+import { PRECONNECT_CHECK_BLOCKLIST } from '../preconnect_link_checker';
+import { isAbsoluteUrl, isValidPath, normalizePath, normalizeSrc } from '../url';
+/**
+ * Noop image loader that does no transformation to the original src and just returns it as is.
+ * This loader is used as a default one if more specific logic is not provided in an app config.
+ *
+ * @see `ImageLoader`
+ * @see `NgOptimizedImage`
+ */
+const noopImageLoader = (config) => config.src;
+/**
+ * Injection token that configures the image loader function.
+ *
+ * @see `ImageLoader`
+ * @see `NgOptimizedImage`
+ * @publicApi
+ * @developerPreview
+ */
+export const IMAGE_LOADER = new InjectionToken('ImageLoader', {
+    providedIn: 'root',
+    factory: () => noopImageLoader,
+});
+/**
+ * Internal helper function that makes it easier to introduce custom image loaders for the
+ * `NgOptimizedImage` directive. It is enough to specify a URL builder function to obtain full DI
+ * configuration for a given loader: a DI token corresponding to the actual loader function, plus DI
+ * tokens managing preconnect check functionality.
+ * @param buildUrlFn a function returning a full URL based on loader's configuration
+ * @param exampleUrls example of full URLs for a given loader (used in error messages)
+ * @returns a set of DI providers corresponding to the configured image loader
+ */
+export function createImageLoader(buildUrlFn, exampleUrls) {
+    return function provideImageLoader(path, options = { ensurePreconnect: true }) {
+        if (!isValidPath(path)) {
+            throwInvalidPathError(path, exampleUrls || []);
+        }
+        // The trailing / is stripped (if provided) to make URL construction (concatenation) easier in
+        // the individual loader functions.
+        path = normalizePath(path);
+        const loaderFn = (config) => {
+            if (isAbsoluteUrl(config.src)) {
+                // Image loader functions expect an image file name (e.g. `my-image.png`)
+                // or a relative path + a file name (e.g. `/a/b/c/my-image.png`) as an input,
+                // so the final absolute URL can be constructed.
+                // When an absolute URL is provided instead - the loader can not
+                // build a final URL, thus the error is thrown to indicate that.
+                throwUnexpectedAbsoluteUrlError(path, config.src);
+            }
+            return buildUrlFn(path, { ...config, src: normalizeSrc(config.src) });
+        };
+        const providers = [{ provide: IMAGE_LOADER, useValue: loaderFn }];
+        if (ngDevMode && options.ensurePreconnect === false) {
+            providers.push({ provide: PRECONNECT_CHECK_BLOCKLIST, useValue: [path], multi: true });
+        }
+        return providers;
+    };
+}
+function throwInvalidPathError(path, exampleUrls) {
+    throw new RuntimeError(2959 /* RuntimeErrorCode.INVALID_LOADER_ARGUMENTS */, ngDevMode &&
+        `Image loader has detected an invalid path (\`${path}\`). ` +
+            `To fix this, supply a path using one of the following formats: ${exampleUrls.join(' or ')}`);
+}
+function throwUnexpectedAbsoluteUrlError(path, url) {
+    throw new RuntimeError(2959 /* RuntimeErrorCode.INVALID_LOADER_ARGUMENTS */, ngDevMode &&
+        `Image loader has detected a \`<img>\` tag with an invalid \`rawSrc\` attribute: ${url}. ` +
+            `This image loader expects \`rawSrc\` to be a relative URL - ` +
+            `however the provided value is an absolute URL. ` +
+            `To fix this, provide \`rawSrc\` as a path relative to the base URL ` +
+            `configured for this loader (\`${path}\`).`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image_loader.js","sourceRoot":"","sources":["../../../../../../../../../packages/common/src/directives/ng_optimized_image/image_loaders/image_loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAY,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAGtF,OAAO,EAAC,0BAA0B,EAAC,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAC,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,QAAQ,CAAC;AA8B/E;;;;;;GAMG;AACH,MAAM,eAAe,GAAG,CAAC,MAAyB,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAAc,aAAa,EAAE;IACzE,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,eAAe;CAC/B,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC7B,UAA+D,EAAE,WAAsB;IACzF,OAAO,SAAS,kBAAkB,CAC9B,IAAY,EAAE,UAAwC,EAAC,gBAAgB,EAAE,IAAI,EAAC;QAChF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YACtB,qBAAqB,CAAC,IAAI,EAAE,WAAW,IAAI,EAAE,CAAC,CAAC;SAChD;QAED,8FAA8F;QAC9F,mCAAmC;QACnC,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QAE3B,MAAM,QAAQ,GAAG,CAAC,MAAyB,EAAE,EAAE;YAC7C,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;gBAC7B,yEAAyE;gBACzE,6EAA6E;gBAC7E,gDAAgD;gBAChD,gEAAgE;gBAChE,gEAAgE;gBAChE,+BAA+B,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;aACnD;YAED,OAAO,UAAU,CAAC,IAAI,EAAE,EAAC,GAAG,MAAM,EAAE,GAAG,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,EAAC,CAAC,CAAC;QACtE,CAAC,CAAC;QACF,MAAM,SAAS,GAAe,CAAC,EAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAC;QAE5E,IAAI,SAAS,IAAI,OAAO,CAAC,gBAAgB,KAAK,KAAK,EAAE;YACnD,SAAS,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,0BAA0B,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;SACtF;QAED,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAa,EAAE,WAAqB;IACjE,MAAM,IAAI,YAAY,uDAElB,SAAS;QACL,gDAAgD,IAAI,OAAO;YACvD,kEACI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,+BAA+B,CAAC,IAAY,EAAE,GAAW;IAChE,MAAM,IAAI,YAAY,uDAElB,SAAS;QACL,mFACI,GAAG,IAAI;YACP,8DAA8D;YAC9D,iDAAiD;YACjD,qEAAqE;YACrE,iCAAiC,IAAI,MAAM,CAAC,CAAC;AAC3D,CAAC","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 {InjectionToken, Provider, ɵRuntimeError as RuntimeError} from '@angular/core';\n\nimport {RuntimeErrorCode} from '../../../errors';\nimport {PRECONNECT_CHECK_BLOCKLIST} from '../preconnect_link_checker';\nimport {isAbsoluteUrl, isValidPath, normalizePath, normalizeSrc} from '../url';\n\n/**\n * Config options recognized by the image loader function.\n *\n * @see `ImageLoader`\n * @see `NgOptimizedImage`\n * @publicApi\n * @developerPreview\n */\nexport interface ImageLoaderConfig {\n  /**\n   * Image file name to be added to the image request URL.\n   */\n  src: string;\n  /**\n   * Width of the requested image (to be used when generating srcset).\n   */\n  width?: number;\n}\n\n/**\n * Represents an image loader function. Image loader functions are used by the\n * NgOptimizedImage directive to produce full image URL based on the image name and its width.\n *\n * @publicApi\n * @developerPreview\n */\nexport type ImageLoader = (config: ImageLoaderConfig) => string;\n\n/**\n * Noop image loader that does no transformation to the original src and just returns it as is.\n * This loader is used as a default one if more specific logic is not provided in an app config.\n *\n * @see `ImageLoader`\n * @see `NgOptimizedImage`\n */\nconst noopImageLoader = (config: ImageLoaderConfig) => config.src;\n\n/**\n * Injection token that configures the image loader function.\n *\n * @see `ImageLoader`\n * @see `NgOptimizedImage`\n * @publicApi\n * @developerPreview\n */\nexport const IMAGE_LOADER = new InjectionToken<ImageLoader>('ImageLoader', {\n  providedIn: 'root',\n  factory: () => noopImageLoader,\n});\n\n/**\n * Internal helper function that makes it easier to introduce custom image loaders for the\n * `NgOptimizedImage` directive. It is enough to specify a URL builder function to obtain full DI\n * configuration for a given loader: a DI token corresponding to the actual loader function, plus DI\n * tokens managing preconnect check functionality.\n * @param buildUrlFn a function returning a full URL based on loader's configuration\n * @param exampleUrls example of full URLs for a given loader (used in error messages)\n * @returns a set of DI providers corresponding to the configured image loader\n */\nexport function createImageLoader(\n    buildUrlFn: (path: string, config: ImageLoaderConfig) => string, exampleUrls?: string[]) {\n  return function provideImageLoader(\n      path: string, options: {ensurePreconnect?: boolean} = {ensurePreconnect: true}) {\n    if (!isValidPath(path)) {\n      throwInvalidPathError(path, exampleUrls || []);\n    }\n\n    // The trailing / is stripped (if provided) to make URL construction (concatenation) easier in\n    // the individual loader functions.\n    path = normalizePath(path);\n\n    const loaderFn = (config: ImageLoaderConfig) => {\n      if (isAbsoluteUrl(config.src)) {\n        // Image loader functions expect an image file name (e.g. `my-image.png`)\n        // or a relative path + a file name (e.g. `/a/b/c/my-image.png`) as an input,\n        // so the final absolute URL can be constructed.\n        // When an absolute URL is provided instead - the loader can not\n        // build a final URL, thus the error is thrown to indicate that.\n        throwUnexpectedAbsoluteUrlError(path, config.src);\n      }\n\n      return buildUrlFn(path, {...config, src: normalizeSrc(config.src)});\n    };\n    const providers: Provider[] = [{provide: IMAGE_LOADER, useValue: loaderFn}];\n\n    if (ngDevMode && options.ensurePreconnect === false) {\n      providers.push({provide: PRECONNECT_CHECK_BLOCKLIST, useValue: [path], multi: true});\n    }\n\n    return providers;\n  };\n}\n\nfunction throwInvalidPathError(path: unknown, exampleUrls: string[]): never {\n  throw new RuntimeError(\n      RuntimeErrorCode.INVALID_LOADER_ARGUMENTS,\n      ngDevMode &&\n          `Image loader has detected an invalid path (\\`${path}\\`). ` +\n              `To fix this, supply a path using one of the following formats: ${\n                  exampleUrls.join(' or ')}`);\n}\n\nfunction throwUnexpectedAbsoluteUrlError(path: string, url: string): never {\n  throw new RuntimeError(\n      RuntimeErrorCode.INVALID_LOADER_ARGUMENTS,\n      ngDevMode &&\n          `Image loader has detected a \\`<img>\\` tag with an invalid \\`rawSrc\\` attribute: ${\n              url}. ` +\n              `This image loader expects \\`rawSrc\\` to be a relative URL - ` +\n              `however the provided value is an absolute URL. ` +\n              `To fix this, provide \\`rawSrc\\` as a path relative to the base URL ` +\n              `configured for this loader (\\`${path}\\`).`);\n}\n"]}

package/esm2020/src/directives/ng_optimized_image/image_loaders/imagekit_loader.mjs ADDED Viewed

@@ -0,0 +1,35 @@
+/**
+ * @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 { createImageLoader } from './image_loader';
+/**
+ * Function that generates an ImageLoader for ImageKit and turns it into an Angular provider.
+ *
+ * @param path Base URL of your ImageKit images
+ * This URL should match one of the following formats:
+ * https://ik.imagekit.io/myaccount
+ * https://subdomain.mysite.com
+ * @param options An object with extra configuration:
+ * - `ensurePreconnect`: boolean flag indicating whether the NgOptimizedImage directive
+ *                       should verify that there is a corresponding `<link rel="preconnect">`
+ *                       present in the document's `<head>`.
+ * @returns Set of providers to configure the ImageKit loader.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export const provideImageKitLoader = createImageLoader(createImagekitUrl, ngDevMode ? ['https://ik.imagekit.io/mysite', 'https://subdomain.mysite.com'] : undefined);
+export function createImagekitUrl(path, config) {
+    // Example of an ImageKit image URL:
+    // https://ik.imagekit.io/demo/tr:w-300,h-300/medium_cafe_B1iTdD0C.jpg
+    let params = `tr:q-auto`; // applies the "auto quality" transformation
+    if (config.width) {
+        params += `,w-${config.width}`;
+    }
+    return `${path}/${params}/${config.src}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/directives/ng_optimized_image/image_loaders/imgix_loader.mjs ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * @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 { createImageLoader } from './image_loader';
+/**
+ * Function that generates an ImageLoader for Imgix and turns it into an Angular provider.
+ *
+ * @param path path to the desired Imgix origin,
+ * e.g. https://somepath.imgix.net or https://images.mysite.com
+ * @param options An object with extra configuration:
+ * - `ensurePreconnect`: boolean flag indicating whether the NgOptimizedImage directive
+ *                       should verify that there is a corresponding `<link rel="preconnect">`
+ *                       present in the document's `<head>`.
+ * @returns Set of providers to configure the Imgix loader.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export const provideImgixLoader = createImageLoader(createImgixUrl, ngDevMode ? ['https://somepath.imgix.net/'] : undefined);
+function createImgixUrl(path, config) {
+    const url = new URL(`${path}/${config.src}`);
+    // This setting ensures the smallest allowable format is set.
+    url.searchParams.set('auto', 'format');
+    if (config.width) {
+        url.searchParams.set('w', config.width.toString());
+    }
+    return url.href;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/directives/ng_optimized_image/index.mjs ADDED Viewed

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+// These exports represent the set of symbols exposed as a public API.
+export { provideCloudflareLoader } from './image_loaders/cloudflare_loader';
+export { provideCloudinaryLoader } from './image_loaders/cloudinary_loader';
+export { IMAGE_LOADER } from './image_loaders/image_loader';
+export { provideImageKitLoader } from './image_loaders/imagekit_loader';
+export { provideImgixLoader } from './image_loaders/imgix_loader';
+export { NgOptimizedImage } from './ng_optimized_image';
+export { PRECONNECT_CHECK_BLOCKLIST } from './preconnect_link_checker';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2RpcmVjdGl2ZXMvbmdfb3B0aW1pemVkX2ltYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILHNFQUFzRTtBQUN0RSxPQUFPLEVBQUMsdUJBQXVCLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQztBQUMxRSxPQUFPLEVBQUMsdUJBQXVCLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQztBQUMxRSxPQUFPLEVBQUMsWUFBWSxFQUFpQyxNQUFNLDhCQUE4QixDQUFDO0FBQzFGLE9BQU8sRUFBQyxxQkFBcUIsRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLDhCQUE4QixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBQywwQkFBMEIsRUFBQyxNQUFNLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8vIFRoZXNlIGV4cG9ydHMgcmVwcmVzZW50IHRoZSBzZXQgb2Ygc3ltYm9scyBleHBvc2VkIGFzIGEgcHVibGljIEFQSS5cbmV4cG9ydCB7cHJvdmlkZUNsb3VkZmxhcmVMb2FkZXJ9IGZyb20gJy4vaW1hZ2VfbG9hZGVycy9jbG91ZGZsYXJlX2xvYWRlcic7XG5leHBvcnQge3Byb3ZpZGVDbG91ZGluYXJ5TG9hZGVyfSBmcm9tICcuL2ltYWdlX2xvYWRlcnMvY2xvdWRpbmFyeV9sb2FkZXInO1xuZXhwb3J0IHtJTUFHRV9MT0FERVIsIEltYWdlTG9hZGVyLCBJbWFnZUxvYWRlckNvbmZpZ30gZnJvbSAnLi9pbWFnZV9sb2FkZXJzL2ltYWdlX2xvYWRlcic7XG5leHBvcnQge3Byb3ZpZGVJbWFnZUtpdExvYWRlcn0gZnJvbSAnLi9pbWFnZV9sb2FkZXJzL2ltYWdla2l0X2xvYWRlcic7XG5leHBvcnQge3Byb3ZpZGVJbWdpeExvYWRlcn0gZnJvbSAnLi9pbWFnZV9sb2FkZXJzL2ltZ2l4X2xvYWRlcic7XG5leHBvcnQge05nT3B0aW1pemVkSW1hZ2V9IGZyb20gJy4vbmdfb3B0aW1pemVkX2ltYWdlJztcbmV4cG9ydCB7UFJFQ09OTkVDVF9DSEVDS19CTE9DS0xJU1R9IGZyb20gJy4vcHJlY29ubmVjdF9saW5rX2NoZWNrZXInO1xuIl19

package/esm2020/src/directives/ng_optimized_image/lcp_image_observer.mjs ADDED Viewed

@@ -0,0 +1,99 @@
+/**
+ * @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 { inject, Injectable, ɵformatRuntimeError as formatRuntimeError } from '@angular/core';
+import { DOCUMENT } from '../../dom_tokens';
+import { assertDevMode } from './asserts';
+import { imgDirectiveDetails } from './error_helper';
+import { getUrl } from './url';
+import * as i0 from "@angular/core";
+/**
+ * Observer that detects whether an image with `NgOptimizedImage`
+ * is treated as a Largest Contentful Paint (LCP) element. If so,
+ * asserts that the image has the `priority` attribute.
+ *
+ * Note: this is a dev-mode only class and it does not appear in prod bundles,
+ * thus there is no `ngDevMode` use in the code.
+ *
+ * Based on https://web.dev/lcp/#measure-lcp-in-javascript.
+ */
+export class LCPImageObserver {
+    constructor() {
+        // Map of full image URLs -> original `rawSrc` values.
+        this.images = new Map();
+        // Keep track of images for which `console.warn` was produced.
+        this.alreadyWarned = new Set();
+        this.window = null;
+        this.observer = null;
+        assertDevMode('LCP checker');
+        const win = inject(DOCUMENT).defaultView;
+        if (typeof win !== 'undefined' && typeof PerformanceObserver !== 'undefined') {
+            this.window = win;
+            this.observer = this.initPerformanceObserver();
+        }
+    }
+    /**
+     * Inits PerformanceObserver and subscribes to LCP events.
+     * Based on https://web.dev/lcp/#measure-lcp-in-javascript
+     */
+    initPerformanceObserver() {
+        const observer = new PerformanceObserver((entryList) => {
+            const entries = entryList.getEntries();
+            if (entries.length === 0)
+                return;
+            // We use the latest entry produced by the `PerformanceObserver` as the best
+            // signal on which element is actually an LCP one. As an example, the first image to load on
+            // a page, by virtue of being the only thing on the page so far, is often a LCP candidate
+            // and gets reported by PerformanceObserver, but isn't necessarily the LCP element.
+            const lcpElement = entries[entries.length - 1];
+            // Cast to `any` due to missing `element` on the `LargestContentfulPaint` type of entry.
+            // See https://developer.mozilla.org/en-US/docs/Web/API/LargestContentfulPaint
+            const imgSrc = lcpElement.element?.src ?? '';
+            // Exclude `data:` and `blob:` URLs, since they are not supported by the directive.
+            if (imgSrc.startsWith('data:') || imgSrc.startsWith('blob:'))
+                return;
+            const imgRawSrc = this.images.get(imgSrc);
+            if (imgRawSrc && !this.alreadyWarned.has(imgSrc)) {
+                this.alreadyWarned.add(imgSrc);
+                logMissingPriorityWarning(imgSrc);
+            }
+        });
+        observer.observe({ type: 'largest-contentful-paint', buffered: true });
+        return observer;
+    }
+    registerImage(rewrittenSrc, rawSrc) {
+        if (!this.observer)
+            return;
+        this.images.set(getUrl(rewrittenSrc, this.window).href, rawSrc);
+    }
+    unregisterImage(rewrittenSrc) {
+        if (!this.observer)
+            return;
+        this.images.delete(getUrl(rewrittenSrc, this.window).href);
+    }
+    ngOnDestroy() {
+        if (!this.observer)
+            return;
+        this.observer.disconnect();
+        this.images.clear();
+        this.alreadyWarned.clear();
+    }
+}
+LCPImageObserver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: LCPImageObserver, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LCPImageObserver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: LCPImageObserver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: LCPImageObserver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+function logMissingPriorityWarning(rawSrc) {
+    const directiveDetails = imgDirectiveDetails(rawSrc);
+    console.warn(formatRuntimeError(2955 /* RuntimeErrorCode.LCP_IMG_MISSING_PRIORITY */, `${directiveDetails} this image is the Largest Contentful Paint (LCP) ` +
+        `element but was not marked "priority". This image should be marked ` +
+        `"priority" in order to prioritize its loading. ` +
+        `To fix this, add the "priority" attribute.`));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lcp_image_observer.js","sourceRoot":"","sources":["../../../../../../../../packages/common/src/directives/ng_optimized_image/lcp_image_observer.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 {inject, Injectable, OnDestroy, ɵformatRuntimeError as formatRuntimeError} from '@angular/core';\n\nimport {DOCUMENT} from '../../dom_tokens';\nimport {RuntimeErrorCode} from '../../errors';\n\nimport {assertDevMode} from './asserts';\nimport {imgDirectiveDetails} from './error_helper';\nimport {getUrl} from './url';\n\n/**\n * Observer that detects whether an image with `NgOptimizedImage`\n * is treated as a Largest Contentful Paint (LCP) element. If so,\n * asserts that the image has the `priority` attribute.\n *\n * Note: this is a dev-mode only class and it does not appear in prod bundles,\n * thus there is no `ngDevMode` use in the code.\n *\n * Based on https://web.dev/lcp/#measure-lcp-in-javascript.\n */\n@Injectable({providedIn: 'root'})\nexport class LCPImageObserver implements OnDestroy {\n  // Map of full image URLs -> original `rawSrc` values.\n  private images = new Map<string, string>();\n  // Keep track of images for which `console.warn` was produced.\n  private alreadyWarned = new Set<string>();\n\n  private window: Window|null = null;\n  private observer: PerformanceObserver|null = null;\n\n  constructor() {\n    assertDevMode('LCP checker');\n    const win = inject(DOCUMENT).defaultView;\n    if (typeof win !== 'undefined' && typeof PerformanceObserver !== 'undefined') {\n      this.window = win;\n      this.observer = this.initPerformanceObserver();\n    }\n  }\n\n  /**\n   * Inits PerformanceObserver and subscribes to LCP events.\n   * Based on https://web.dev/lcp/#measure-lcp-in-javascript\n   */\n  private initPerformanceObserver(): PerformanceObserver {\n    const observer = new PerformanceObserver((entryList) => {\n      const entries = entryList.getEntries();\n      if (entries.length === 0) return;\n      // We use the latest entry produced by the `PerformanceObserver` as the best\n      // signal on which element is actually an LCP one. As an example, the first image to load on\n      // a page, by virtue of being the only thing on the page so far, is often a LCP candidate\n      // and gets reported by PerformanceObserver, but isn't necessarily the LCP element.\n      const lcpElement = entries[entries.length - 1];\n\n      // Cast to `any` due to missing `element` on the `LargestContentfulPaint` type of entry.\n      // See https://developer.mozilla.org/en-US/docs/Web/API/LargestContentfulPaint\n      const imgSrc = (lcpElement as any).element?.src ?? '';\n\n      // Exclude `data:` and `blob:` URLs, since they are not supported by the directive.\n      if (imgSrc.startsWith('data:') || imgSrc.startsWith('blob:')) return;\n\n      const imgRawSrc = this.images.get(imgSrc);\n      if (imgRawSrc && !this.alreadyWarned.has(imgSrc)) {\n        this.alreadyWarned.add(imgSrc);\n        logMissingPriorityWarning(imgSrc);\n      }\n    });\n    observer.observe({type: 'largest-contentful-paint', buffered: true});\n    return observer;\n  }\n\n  registerImage(rewrittenSrc: string, rawSrc: string) {\n    if (!this.observer) return;\n    this.images.set(getUrl(rewrittenSrc, this.window!).href, rawSrc);\n  }\n\n  unregisterImage(rewrittenSrc: string) {\n    if (!this.observer) return;\n    this.images.delete(getUrl(rewrittenSrc, this.window!).href);\n  }\n\n  ngOnDestroy() {\n    if (!this.observer) return;\n    this.observer.disconnect();\n    this.images.clear();\n    this.alreadyWarned.clear();\n  }\n}\n\nfunction logMissingPriorityWarning(rawSrc: string) {\n  const directiveDetails = imgDirectiveDetails(rawSrc);\n  console.warn(formatRuntimeError(\n      RuntimeErrorCode.LCP_IMG_MISSING_PRIORITY,\n      `${directiveDetails} this image is the Largest Contentful Paint (LCP) ` +\n          `element but was not marked \"priority\". This image should be marked ` +\n          `\"priority\" in order to prioritize its loading. ` +\n          `To fix this, add the \"priority\" attribute.`));\n}\n"]}