carbon-components-angular
Version:
Next generation components
140 lines • 15.7 kB
JavaScript
import { Injectable } from "@angular/core";
import { toString } from "@carbon/icon-helpers";
import * as i0 from "@angular/core";
/**
* Abstract class that represent a cache of icons.
*
* The actual caching mechanism will be implementation specific,
* but it's likely a good idea to key by the icons name and/or size.
* Icon name and size will always be strings, and they will be the two consistent
* identifiers of an icon. For the purposes of storage additonal descriptor properties may
* be used, but the name and size are the only ones guarenteed to be passed for lookup purposes.
*/
export class IconCache {
}
/**
* Custom error for when a name can't be found
*/
export class IconNameNotFoundError extends Error {
constructor(name) {
super(`Icon ${name} not found`);
}
}
/**
* Custom error for when a specific size can't be found
*/
export class IconSizeNotFoundError extends Error {
constructor(size, name) {
super("Size ${size} for ${name} not found");
}
}
/**
* Concrete implementation of `IconCache` as a simple in memory cache
*/
export class IconMemoryCache extends IconCache {
constructor() {
super(...arguments);
this.iconMap = new Map();
}
get(name, size) {
if (!this.iconMap.has(name)) {
throw new IconNameNotFoundError(name);
}
const sizeMap = this.iconMap.get(name);
if (!sizeMap.has(size)) {
throw new IconSizeNotFoundError(size, name);
}
return sizeMap.get(size);
}
set(name, size, descriptor) {
if (!this.iconMap.has(name)) {
this.iconMap.set(name, new Map());
}
const sizeMap = this.iconMap.get(name);
sizeMap.set(size, descriptor);
}
}
/**
* The icon service is a singleton service responsible for registering and retriving icons from `@carbon/icons`.
*
* It's important to register icons before use. It's reccommended to register your icons early, likely in your app.component.
*
* To allow for improved tree shaking _do not_ import all the icons from `@carbon/icons` and register them.
* Instead register only the icons in use by your application. If your application makes use of lazy loaded
* modules you may also lazy load the icons used in that module by registering them early on in that module.
*
* `ngOnInit` should be sufficiantly early to register icons.
*
* Example:
* ```
* import { Accessibility16 } from "@carbon/icons";
*
* // ...
*
* class MyComponent implements OnInit {
* constructor(protected iconService: IconService) {}
*
* // ...
*
* ngOnInit() {
* this.iconService.register(Accessibility16);
* }
*
* // ...
* }
* ```
*
* If needed it is possible to register an icon under a different name, via `registerAs`.
*/
export class IconService {
constructor() {
this.iconCache = new IconMemoryCache();
}
/**
* Registers an array of icons based on the metadata provided by `@carbon/icons`
*/
registerAll(descriptors) {
descriptors.forEach(icon => this.register(icon));
}
/**
* Registers an icon based on the metadata provided by `@carbon/icons`
*/
register(descriptor) {
const { name } = descriptor;
this.registerAs(name, descriptor);
}
/**
* Registers an icon based on a uniqe name and metadata provided by `@carbon/icons`
*/
registerAs(name, descriptor) {
const { size } = descriptor;
this.iconCache.set(name, size.toString(), descriptor);
}
/**
* Gets an icon, converts it to a string, and caches the result
*/
get(name, size) {
try {
const icon = this.iconCache.get(name, size.toString());
if (!icon.svg) {
icon.svg = toString(icon);
}
return icon;
}
catch (e) {
throw e;
}
}
/**
* Configure various service settings (caching strategy ...)
*/
configure(options) {
this.iconCache = options.cache;
}
}
IconService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IconService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
IconService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IconService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IconService, decorators: [{
type: Injectable
}] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.service.js","sourceRoot":"","sources":["../../../src/icon/icon.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { toString } from \"@carbon/icon-helpers\";\n\n// icon imports\nimport {\n\tAdd16,\n\tCalendar16,\n\tCaretDown16,\n\tCaretLeft16,\n\tCaretRight16,\n\tCaretUp16,\n\tCheckmark16,\n\tCheckmarkFilled16,\n\tCheckmarkOutline16,\n\tChevronDown16,\n\tChevronRight16,\n\tClose16,\n\tCopy16,\n\tDownload16,\n\tErrorFilled16,\n\tInformationFilled16,\n\tMenu16,\n\tOverflowMenuVertical16,\n\tSave16,\n\tSettings16,\n\tTrashCan16,\n\tWarning16,\n\tWarningFilled16\n} from \"@carbon/icons\";\n\n/**\n * An object that represents a parsed icon\n */\nexport interface IconDescriptor {\n\t/**\n\t * The element to render. For the root this is `svg`\n\t */\n\telem: string;\n\t/**\n\t * An object of attributes to apply to the element.\n\t *\n\t * The type here is non-exhaustive.\n\t */\n\tattrs: {\n\t\txmlns: string,\n\t\t// needed by the icon directive to determine other attributes\n\t\tviewBox: string,\n\t\tfill: string,\n\t\t// needed by the icon directive to determine other attributes\n\t\twidth: string,\n\t\t// needed by the icon directive to determine other attributes\n\t\theight: string,\n\t\t[x: string]: string\n\t};\n\t/**\n\t * The content (children) of the element as an array of `IconDescriptor`s\n\t * (usually without a few fields, namely `name` and `size`)\n\t */\n\tcontent: IconDescriptor[];\n\t/**\n\t * The name of the icon.\n\t *\n\t * Needed by the icon service.\n\t */\n\tname: string;\n\t/**\n\t * The size of the icon in pixels.\n\t *\n\t * Needed by the icon service.\n\t */\n\tsize: number;\n\t/**\n\t * Optional. A string representation of the compiled svg.\n\t * If missing the icon service will add this.\n\t */\n\tsvg?: string;\n}\n\n/**\n * Abstract class that represent a cache of icons.\n *\n * The actual caching mechanism will be implementation specific,\n * but it's likely a good idea to key by the icons name and/or size.\n * Icon name and size will always be strings, and they will be the two consistent\n * identifiers of an icon. For the purposes of storage additonal descriptor properties may\n * be used, but the name and size are the only ones guarenteed to be passed for lookup purposes.\n */\nexport abstract class IconCache {\n\t/**\n\t * Finds and returns an icon based on it's name and size\n\t */\n\tabstract get(name: string, size: string): object;\n\t/**\n\t * stores an icon descriptor to the cache\n\t */\n\tabstract set(name: string, size: string, descriptor: object): void;\n}\n\n/**\n * Custom error for when a name can't be found\n */\nexport class IconNameNotFoundError extends Error {\n\tconstructor(name: string) {\n\t\tsuper(`Icon ${name} not found`);\n\t}\n}\n\n/**\n * Custom error for when a specific size can't be found\n */\nexport class IconSizeNotFoundError extends Error {\n\tconstructor(size: string, name: string) {\n\t\tsuper(\"Size ${size} for ${name} not found\");\n\t}\n}\n\n/**\n * Concrete implementation of `IconCache` as a simple in memory cache\n */\nexport class IconMemoryCache extends IconCache {\n\tprivate iconMap = new Map<string, Map<string, object>>();\n\n\tget(name: string, size: string) {\n\t\tif (!this.iconMap.has(name)) {\n\t\t\tthrow new IconNameNotFoundError(name);\n\t\t}\n\t\tconst sizeMap = this.iconMap.get(name);\n\t\tif (!sizeMap.has(size)) {\n\t\t\tthrow new IconSizeNotFoundError(size, name);\n\t\t}\n\t\treturn sizeMap.get(size);\n\t}\n\n\tset(name: string, size: string, descriptor: object) {\n\t\tif (!this.iconMap.has(name)) {\n\t\t\tthis.iconMap.set(name, new Map());\n\t\t}\n\t\tconst sizeMap = this.iconMap.get(name);\n\t\tsizeMap.set(size, descriptor);\n\t}\n}\n\n/**\n * The icon service is a singleton service responsible for registering and retriving icons from `@carbon/icons`.\n *\n * It's important to register icons before use. It's reccommended to register your icons early, likely in your app.component.\n *\n * To allow for improved tree shaking _do not_ import all the icons from `@carbon/icons` and register them.\n * Instead register only the icons in use by your application. If your application makes use of lazy loaded\n * modules you may also lazy load the icons used in that module by registering them early on in that module.\n *\n * `ngOnInit` should be sufficiantly early to register icons.\n *\n * Example:\n * ```\n * import { Accessibility16 } from \"@carbon/icons\";\n *\n * // ...\n *\n * class MyComponent implements OnInit {\n * \tconstructor(protected iconService: IconService) {}\n *\n * \t// ...\n *\n * \tngOnInit() {\n * \t\tthis.iconService.register(Accessibility16);\n * \t}\n *\n * \t// ...\n * }\n * ```\n *\n * If needed it is possible to register an icon under a different name, via `registerAs`.\n */\n@Injectable()\nexport class IconService {\n\tprivate iconCache: IconCache = new IconMemoryCache();\n\n\t/**\n\t * Registers an array of icons based on the metadata provided by `@carbon/icons`\n\t */\n\tpublic registerAll(descriptors: object[]) {\n\t\tdescriptors.forEach(icon => this.register(icon));\n\t}\n\n\t/**\n\t * Registers an icon based on the metadata provided by `@carbon/icons`\n\t */\n\tpublic register(descriptor: object) {\n\t\tconst { name } = descriptor as IconDescriptor;\n\t\tthis.registerAs(name, descriptor);\n\t}\n\n\t/**\n\t * Registers an icon based on a uniqe name and metadata provided by `@carbon/icons`\n\t */\n\tpublic registerAs(name: string, descriptor: object) {\n\t\tconst { size } = descriptor as IconDescriptor;\n\t\tthis.iconCache.set(name, size.toString(), descriptor);\n\t}\n\n\t/**\n\t * Gets an icon, converts it to a string, and caches the result\n\t */\n\tpublic get(name: string, size: string): IconDescriptor {\n\t\ttry {\n\t\t\tconst icon = this.iconCache.get(name, size.toString()) as IconDescriptor;\n\t\t\tif (!icon.svg) {\n\t\t\t\ticon.svg = toString(icon);\n\t\t\t}\n\t\t\treturn icon;\n\t\t} catch (e) {\n\t\t\tthrow e;\n\t\t}\n\t}\n\n\t/**\n\t * Configure various service settings (caching strategy ...)\n\t */\n\tpublic configure(options: { cache: IconCache }) {\n\t\tthis.iconCache = options.cache;\n\t}\n}\n"]}