@angular/common
Version:
Angular - commonly needed directives and services
74 lines • 12 kB
JavaScript
/**
* @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 { 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`
*/
export const noopImageLoader = (config) => config.src;
/**
* Injection token that configures the image loader function.
*
* @see `ImageLoader`
* @see `NgOptimizedImage`
* @publicApi
*/
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) {
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 }];
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 \`ngSrc\` attribute: ${url}. ` +
`This image loader expects \`ngSrc\` to be a relative URL - ` +
`however the provided value is an absolute URL. ` +
`To fix this, provide \`ngSrc\` 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,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,QAAQ,CAAC;AA4B/E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAyB,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;AAUzE;;;;;;GAMG;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,CAAC,IAAY;QAC7C,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;QAEF,MAAM,SAAS,GAAe,CAAC,EAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAC;QAC5E,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,kFACI,GAAG,IAAI;YACP,6DAA6D;YAC7D,iDAAiD;YACjD,oEAAoE;YACpE,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 {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 */\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 */\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 */\nexport const noopImageLoader = (config: ImageLoaderConfig) => config.src;\n\n/**\n * Metadata about the image loader.\n */\nexport type ImageLoaderInfo = {\n  name: string,\n  testUrl: (url: string) => boolean\n};\n\n/**\n * Injection token that configures the image loader function.\n *\n * @see `ImageLoader`\n * @see `NgOptimizedImage`\n * @publicApi\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(path: string) {\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\n    const providers: Provider[] = [{provide: IMAGE_LOADER, useValue: loaderFn}];\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 \\`ngSrc\\` attribute: ${\n              url}. ` +\n              `This image loader expects \\`ngSrc\\` to be a relative URL - ` +\n              `however the provided value is an absolute URL. ` +\n              `To fix this, provide \\`ngSrc\\` as a path relative to the base URL ` +\n              `configured for this loader (\\`${path}\\`).`);\n}\n"]}