@loomidev/icons 0.9.0 → 0.10.0

package/README.md

@@ -2,58 +2,118 @@
 
 The shared icon registry used across loomi components, covering three sources:
 
-- **`heroicons`** (default) - generated from the official Heroicons 24px outline and
-  solid sets, then published as plain Lit SVG templates inlined directly into this
-  package. No React or Heroicons runtime dependency ships to consumers.
-- **`iconsax`** and **`untitledui`** - disk-based. Unlike Heroicons, these are loaded one
-  icon at a time rather than inlined as JS strings. A consumer using one icon from a
-  3,800-icon set only ever loads that one icon - resolved once, cached in memory for the
-  rest of the page's lifetime - instead of every component on the page paying for the
-  whole set up front. They ship twice: as per-icon ES modules under
-  `dist/icons/<source>/<type>/<name>.js`, and as the original `.svg` files under
-  `dist/svg/<source>/<type>/<name>.svg`.
+- **`heroicons`** (default) - the official Heroicons 24px outline and solid sets, as plain
+  Lit SVG templates. No React or Heroicons runtime dependency ships to consumers.
+- **`iconsax`** and **`untitledui`** - disk-based sets, enabled per app with one import.
+
+Every icon is its own module and loads the first time something renders it, so a page
+that shows three icons downloads three icons, not a set. Nothing here costs you icon data
+until an icon is on screen.
 
 ```bash
 npm install @loomidev/icons lit
 ```
 
-## Heroicons (inlined)
+## Heroicons
+
+Components that take an icon name (`<loomi-icon>`, `<loomi-button icon="…">`,
+`<loomi-input prefix-icon="…">`, `<loomi-alert>`, `<loomi-tabs>`, …) all read from this one
+registry, so an icon you register is available everywhere.
+
+A named icon renders as soon as its module arrives, usually within the same frame on a
+warm cache. A component's own built-in icons (a clear button, a chevron, the password
+reveal eye) are imported statically by that component and render on first paint.
 
 ```ts
-import { getLoomiIcon, registerLoomiIcon, loomiIconNames } from "@loomidev/icons";
+import { registerLoomiIcon, hasLoomiIcon, loadLoomiIcon } from "@loomidev/icons";
 import { svg } from "lit";
 
-registerLoomiIcon("rocket", svg`<path d="…" />`);
-getLoomiIcon("bell-alert", "solid");
-loomiIconNames(); // -> ["arrow-path", "bell-alert", …]
+registerLoomiIcon("rocket", svg`<path d="…" />`); // your own icon, or override a Heroicon
+hasLoomiIcon("bell-alert"); // true: a known name, checked without loading anything
+await loadLoomiIcon("bell-alert", "solid"); // load one ahead of time
+```
+
+### Load every Heroicon up front
+
+If you'd rather pay for the whole set once than load icons one by one, for example in an
+app that shows dozens of different icons on its first screen, import it eagerly:
+
+```ts
+import "@loomidev/icons/all";
+```
+
+Every named icon then renders synchronously. Icons you registered still win. This adds
+the size shown under [Bundle size](#bundle-size).
+
+### Importing one icon directly
+
+Each Heroicon is also a subpath module you can import statically. It ships inside your
+bundle with no lazy load:
+
+```ts
+import bell from "@loomidev/icons/heroicons/outline/bell.js";
+import { provideLoomiIcons } from "@loomidev/icons";
+
+provideLoomiIcons({ bell }); // `icon="bell"` now renders on first paint
 ```
 
-Components that render icons (`<loomi-icon>`, `<loomi-button>`, `<loomi-input>`,
-`<loomi-alert>`, `<loomi-tabs>`) all read from this one registry, so an icon you register
-is available everywhere.
+### Rendering icons in your own Lit components
+
+```ts
+import { hasLoomiIcon, loomiIcon } from "@loomidev/icons";
 
-| Export                                  | Description                                                                                                                       |
-| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `getLoomiIcon(name, variant)`           | Returns the icon's inner SVG (a Lit `SVGTemplateResult`) or `undefined`. `variant` is `outline` or `solid`; default is `outline`. |
-| `registerLoomiIcon(name, svg, variant)` | Register or override an icon for `outline` or `solid`; default is `outline`.                                                      |
-| `loomiIconNames(variant)`               | List all registered icon names for a variant; default is `outline`.                                                               |
+render() {
+  return hasLoomiIcon(this.icon)
+    ? html`<svg viewBox="0 0 24 24" fill="none" stroke="currentColor">${loomiIcon(this.icon)}</svg>`
+    : nothing;
+}
+```
+
+`loomiIcon(name, variant?)` is a Lit directive: it renders the icon right away when it's
+available and otherwise fills it in once it loads.
+
+| Export                                  | Description                                                                                                             |
+| --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `loomiIcon(name, variant?)`             | Lit directive that renders an icon's inner SVG, loading it on first use. `variant` is `outline` (default) or `solid`.   |
+| `hasLoomiIcon(name, variant?)`          | Whether the name is a known icon (registered, provided, or a shipped Heroicon). Synchronous; loads nothing.             |
+| `loadLoomiIcon(name, variant?)`         | Loads (once, then cached) and resolves the icon's inner SVG, or `undefined` for an unknown name or a failed load.       |
+| `getLoomiIcon(name, variant?)`          | The icon's inner SVG if it's ready now (registered, provided or already loaded), else `undefined`. Never starts a load. |
+| `registerLoomiIcon(name, svg, variant)` | Register or override an icon for `outline` or `solid`; default is `outline`.                                            |
+| `provideLoomiIcons(icons, variant?)`    | Hand over statically imported icons so they render synchronously. Never replaces an icon you registered.                |
+| `loomiIconNames(variant)`               | List every known icon name for a variant; default is `outline`.                                                         |
+| `isLoomiIconAvailable(name, variant?)`  | Whether the icon is registered, provided or already loaded, i.e. renders with no load.                                  |
+| `registeredLoomiIconNames(variant?)`    | Names registered or provided for a variant (not the shipped set).                                                       |
+
+A solid icon that doesn't exist falls back to its outline version.
 
 ## Iconsax and Untitled UI (disk-based)
 
-Most consumers should just use `<loomi-icon source="iconsax" name="…">` (see
-[`@loomidev/icon`](../icon)) rather than calling these directly - they exist so other
-components can adopt the same sources later the way they already do for Heroicons.
+These sets are opt-in. Import each one you use once, anywhere in your app:
 
-| Source       | Types                                       |
-| ------------ | ------------------------------------------- |
-| `iconsax`    | `outline` (default), `solid`, `twotone`     |
-| `untitledui` | `outline` (default; the only type it ships) |
+```ts
+import "@loomidev/icons/iconsax";
+import "@loomidev/icons/untitledui";
+```
+
+`<loomi-icon source="iconsax" name="home">` (see [`@loomidev/icon`](../icon)) and every
+component with an `icon-source` attribute then render from it. Until a source is
+imported, its names are unknown: the component shows its slot fallback and logs a
+one-time warning naming the import to add. An app that never imports a set bundles none
+of it, not even its name list.
+
+| Source       | Types                                       | Icons |
+| ------------ | ------------------------------------------- | ----- |
+| `iconsax`    | `outline` (default), `solid`, `twotone`     | 2,686 |
+| `untitledui` | `outline` (default; the only type it ships) | 1,173 |
+
+Most consumers should just use `<loomi-icon>` rather than calling these directly.
 
 | Export                                               | Description                                                                                                                                                                                                                 |
 | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `loadLoomiDiskIcon(source, name, type?)`             | Loads (and caches) the icon, resolving to a value renderable directly inside a Lit `html` template: `` html`<svg>${await loadLoomiDiskIcon(...)}</svg>` ``. Resolves `undefined` for an unregistered name or a failed load. |
-| `hasLoomiDiskIcon(source, name, type?)`              | Whether the name is a real icon. Synchronous - it only consults the name manifest, and loads nothing.                                                                                                                       |
-| `registerLoomiDiskIcon(source, name, markup, type?)` | Register a statically imported icon so it renders with no network request and no dynamic chunk. See [Static imports](#static-imports).                                                                                      |
+| `hasLoomiDiskIcon(source, name, type?)`              | Whether the name is a real icon. Synchronous - it only consults the source's name list, so it's `false` until the source is imported.                                                                                       |
+| `registerLoomiDiskIcon(source, name, markup, type?)` | Register a statically imported icon so it renders with no network request and no dynamic chunk, even without importing its source. See [Static imports](#static-imports).                                                   |
+| `isLoomiDiskIconSourceRegistered(source)`            | Whether `@loomidev/icons/<source>` has been imported.                                                                                                                                                                       |
 | `setLoomiIconBasePath(path)`                         | Serve the raw `.svg` files from a path you control instead of loading the modules. See [Serving the SVGs yourself](#serving-the-svgs-yourself). Pass `undefined` to go back to modules.                                     |
 | `getLoomiIconBasePath()`                             | The base path currently set, or `undefined` when icons load from the generated modules.                                                                                                                                     |
 | `getLoomiDiskIconUrl(source, name, type?)`           | Resolves to the icon's `.svg` URL, or `undefined` if `name` isn't registered. An unavailable `type` for that source (e.g. `untitledui` + `"twotone"`) falls back to `outline` rather than failing.                          |
@@ -85,7 +145,7 @@ cannot survive is bundling: a bundler inlines this module into a chunk and never
 ### Static imports
 
 Importing an icon directly is the leanest option - no runtime lookup, no dynamic chunk,
-and dead icons drop out of the bundle:
+no source import needed, and dead icons drop out of the bundle:
 
 ```ts
 import homeOutline from "@loomidev/icons/icons/iconsax/outline/home.js";
@@ -116,6 +176,58 @@ Relative paths resolve against the document. A failed fetch resolves to `undefin
 rather than throwing, so a wrong base path degrades to the component's slot fallback
 instead of breaking the page.
 
+## Fewer, bigger icon chunks
+
+Because every icon is its own module, your bundler emits one small lazy chunk per icon it
+can reach: 648 for Heroicons, plus one per icon in each disk-based set you import (about
+3,900 for both). Only the icons a page renders are ever downloaded, but a long list of
+files can slow builds and clutter deploys.
+
+To trade that for one chunk per set, group them in your bundler config. A page then
+downloads the whole set the first time it shows any icon from it: about 35 KB gzipped per
+Heroicons variant, and up to about 375 KB for an Iconsax type, so this suits Heroicons far
+better than the disk-based sets.
+
+Vite (Rollup):
+
+```js
+// vite.config.js
+export default {
+  build: {
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          const match = id.match(/@loomidev\/icons\/dist\/(heroicons|icons\/[^/]+)\/([^/]+)\//);
+          if (match) return `icons-${match[1].replace("icons/", "")}-${match[2]}`;
+        },
+      },
+    },
+  },
+};
+```
+
+webpack:
+
+```js
+// webpack.config.js
+module.exports = {
+  optimization: {
+    splitChunks: {
+      cacheGroups: {
+        heroicons: {
+          test: /@loomidev[\\/]icons[\\/]dist[\\/]heroicons[\\/]/,
+          name: "icons-heroicons",
+          chunks: "async",
+        },
+      },
+    },
+  },
+};
+```
+
+For the disk-based sets, [serving the SVGs yourself](#serving-the-svgs-yourself) removes
+their chunks entirely.
+
 ### Adding another disk-based source later
 
 There's no source-specific code to touch. Vendor the new set with the generic import
@@ -124,10 +236,19 @@ files):
 
 ```bash
 node scripts/import-icon-set.mjs --source <name> --from /path/to/icons
-pnpm build   # regenerates the name manifest and copies the files into dist/svg/
+pnpm build   # regenerates the source entry and copies the files into dist/svg/
 ```
 
-Then widen `LoomiDiskIconSource` in `src/disk-icons.ts` to include the new name.
+Then widen `LoomiDiskIconSource` in `src/disk-icons.ts` to include the new name, and add
+`./<name>` to `exports` in `package.json`.
+
+<!-- bundle-size:start -->
+
+## Bundle size
+
+The registry is about **3.3 KB** minified and gzipped, excluding `lit`, and loads no icon data up front. Each Heroicon is its own module of a few hundred bytes, loaded the first time it renders. `import "@loomidev/icons/all"` loads every Heroicon eagerly instead: about 72.9 KB. Measured by `pnpm check:bundle-size`.
+
+<!-- bundle-size:end -->
 
 ## Dependencies
 

package/custom-elements.json

@@ -2,10 +2,79 @@
   "schemaVersion": "1.0.0",
   "readme": "",
   "modules": [
+    {
+      "kind": "javascript-module",
+      "path": "src/all.ts",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/directive.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "loomiIcon",
+          "description": "Renders a Heroicon's inner SVG inside an `<svg>` element, loading that one icon on\nfirst use: `` svg`<svg viewBox=\"0 0 24 24\">${loomiIcon(\"bell\")}</svg>` ``.\n\nRenders synchronously when the icon is already registered, provided or loaded;\notherwise it renders nothing and fills in once the icon's module arrives. Check\nhasLoomiIcon first when an unknown name should fall back to something else."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "loomiIcon",
+          "declaration": {
+            "name": "loomiIcon",
+            "module": "src/directive.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/disk-icons.ts",
       "declarations": [
+        {
+          "kind": "function",
+          "name": "registerLoomiDiskIconSource",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "source",
+              "type": {
+                "text": "LoomiDiskIconSource"
+              }
+            },
+            {
+              "name": "sets",
+              "type": {
+                "text": "Partial<Record<LoomiIconType, LoomiDiskIconSetEntry>>"
+              }
+            }
+          ],
+          "description": "Registers a disk-based source's names and lazy loaders. Called by the generated\n`@loomidev/icons/<source>` entries; you shouldn't need to call it yourself."
+        },
+        {
+          "kind": "function",
+          "name": "isLoomiDiskIconSourceRegistered",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "parameters": [
+            {
+              "name": "source",
+              "type": {
+                "text": "LoomiDiskIconSource"
+              }
+            }
+          ],
+          "description": "Whether `@loomidev/icons/<source>` has been imported."
+        },
         {
           "kind": "function",
           "name": "setLoomiIconBasePath",
@@ -123,7 +192,7 @@
               }
             }
           ],
-          "description": "Whether `(source, name)` is a real icon in this package. Cheap and\nsynchronous — it only consults the generated name manifest."
+          "description": "Whether `(source, name)` is a real icon in this package. Cheap and\nsynchronous — it only consults the source's name list, so it is `false` for\nevery name until `@loomidev/icons/<source>` has been imported."
         },
         {
           "kind": "function",
@@ -226,6 +295,22 @@
         }
       ],
       "exports": [
+        {
+          "kind": "js",
+          "name": "registerLoomiDiskIconSource",
+          "declaration": {
+            "name": "registerLoomiDiskIconSource",
+            "module": "src/disk-icons.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "isLoomiDiskIconSourceRegistered",
+          "declaration": {
+            "name": "isLoomiDiskIconSourceRegistered",
+            "module": "src/disk-icons.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "setLoomiIconBasePath",
@@ -335,6 +420,56 @@
           ],
           "description": "Register (or override) an icon by name so `icon=\"<name>\"` can render it."
         },
+        {
+          "kind": "function",
+          "name": "provideLoomiIcons",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "icons",
+              "type": {
+                "text": "Record<string, SVGTemplateResult>"
+              }
+            },
+            {
+              "name": "variant",
+              "default": "\"outline\"",
+              "type": {
+                "text": "LoomiIconVariant"
+              }
+            }
+          ],
+          "description": "Hand over icons that are already imported, so they render synchronously with no\nlazy load. Unlike registerLoomiIcon, this never replaces an icon an app\nregistered, so a component providing its own chrome icons can't clobber an\napp's override."
+        },
+        {
+          "kind": "function",
+          "name": "isLoomiIconAvailable",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "parameters": [
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "variant",
+              "default": "\"outline\"",
+              "type": {
+                "text": "LoomiIconVariant"
+              }
+            }
+          ],
+          "description": "Whether `name` is registered or provided for `variant`, i.e. renders without a load."
+        },
         {
           "kind": "function",
           "name": "getLoomiIcon",
@@ -358,11 +493,36 @@
               }
             }
           ],
-          "description": "Returns the inner SVG for an icon name, or `undefined` if it isn't registered."
+          "description": "The icon's inner SVG if it is ready to render right now — registered, provided,\nor already loaded — else `undefined`. It never starts a load: use\nloadLoomiIcon, or render through the `loomiIcon()` directive, which does\nboth. Use `hasLoomiIcon()` to ask whether a name exists at all."
         },
         {
           "kind": "function",
-          "name": "loomiIconNames",
+          "name": "loadLoomiIcon",
+          "return": {
+            "type": {
+              "text": "Promise<SVGTemplateResult | undefined>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "variant",
+              "default": "\"outline\"",
+              "type": {
+                "text": "LoomiIconVariant"
+              }
+            }
+          ],
+          "description": "Loads (once, then cached) and resolves the icon's inner SVG, or `undefined` for an\nunknown name or a failed load. A `solid` request for an icon with no solid version\nresolves to its outline icon."
+        },
+        {
+          "kind": "function",
+          "name": "registeredLoomiIconNames",
           "return": {
             "type": {
               "text": "string[]"
@@ -377,7 +537,7 @@
               }
             }
           ],
-          "description": "Names of all currently-registered icons."
+          "description": "Names registered or provided for a variant (shipped Heroicons not yet loaded aren't included)."
         }
       ],
       "exports": [
@@ -389,6 +549,22 @@
             "module": "src/heroicons.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "provideLoomiIcons",
+          "declaration": {
+            "name": "provideLoomiIcons",
+            "module": "src/heroicons.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "isLoomiIconAvailable",
+          "declaration": {
+            "name": "isLoomiIconAvailable",
+            "module": "src/heroicons.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "getLoomiIcon",
@@ -399,9 +575,17 @@
         },
         {
           "kind": "js",
-          "name": "loomiIconNames",
+          "name": "loadLoomiIcon",
           "declaration": {
-            "name": "loomiIconNames",
+            "name": "loadLoomiIcon",
+            "module": "src/heroicons.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "registeredLoomiIconNames",
+          "declaration": {
+            "name": "registeredLoomiIconNames",
             "module": "src/heroicons.ts"
           }
         }
@@ -420,6 +604,22 @@
             "module": "src/heroicons.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/names.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/directive.js"
+          }
+        },
         {
           "kind": "js",
           "name": "*",
@@ -429,6 +629,74 @@
           }
         }
       ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/names.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "hasLoomiIcon",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "parameters": [
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "variant",
+              "default": "\"outline\"",
+              "type": {
+                "text": "LoomiIconVariant"
+              }
+            }
+          ],
+          "description": "Whether `name` is a known icon (registered, provided, or a shipped Heroicon). Loads\nnothing. A `solid` name with only an outline version counts, since it renders that."
+        },
+        {
+          "kind": "function",
+          "name": "loomiIconNames",
+          "return": {
+            "type": {
+              "text": "string[]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "variant",
+              "default": "\"outline\"",
+              "type": {
+                "text": "LoomiIconVariant"
+              }
+            }
+          ],
+          "description": "Names of every known icon for a variant: the shipped Heroicons plus any registered ones."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "hasLoomiIcon",
+          "declaration": {
+            "name": "hasLoomiIcon",
+            "module": "src/names.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "loomiIconNames",
+          "declaration": {
+            "name": "loomiIconNames",
+            "module": "src/names.ts"
+          }
+        }
+      ]
     }
   ]
 }

package/dist/all.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=all.d.ts.map

package/dist/all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../src/all.ts"],"names":[],"mappings":""}

package/dist/all.js

@@ -0,0 +1,11 @@
+// `import "@loomidev/icons/all";` — every Heroicon, eagerly, in the importing chunk.
+//
+// Opt-in for apps that would rather pay the whole set (~73 KB gzipped, both variants) up front than
+// load icons one by one: every `icon="<name>"` then renders synchronously on first
+// paint. Icons an app registered with registerLoomiIcon() still win.
+import { provideLoomiIcons } from "./heroicons.js";
+import outline from "./heroicons/outline/all.js";
+import solid from "./heroicons/solid/all.js";
+provideLoomiIcons(outline, "outline");
+provideLoomiIcons(solid, "solid");
+//# sourceMappingURL=all.js.map

package/dist/all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.js","sourceRoot":"","sources":["../src/all.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,EAAE;AACF,oGAAoG;AACpG,mFAAmF;AACnF,qEAAqE;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,OAAO,MAAM,4BAA4B,CAAC;AACjD,OAAO,KAAK,MAAM,0BAA0B,CAAC;AAE7C,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACtC,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC"}

package/dist/directive.d.ts

@@ -0,0 +1,19 @@
+import { nothing, type SVGTemplateResult } from "lit";
+import { AsyncDirective } from "lit/async-directive.js";
+import { type LoomiIconVariant } from "./heroicons.js";
+declare class LoomiIconDirective extends AsyncDirective {
+    private request;
+    render(name: string, variant?: LoomiIconVariant): SVGTemplateResult | typeof nothing;
+    protected reconnected(): void;
+}
+/**
+ * Renders a Heroicon's inner SVG inside an `<svg>` element, loading that one icon on
+ * first use: `` svg`<svg viewBox="0 0 24 24">${loomiIcon("bell")}</svg>` ``.
+ *
+ * Renders synchronously when the icon is already registered, provided or loaded;
+ * otherwise it renders nothing and fills in once the icon's module arrives. Check
+ * {@link hasLoomiIcon} first when an unknown name should fall back to something else.
+ */
+export declare const loomiIcon: (name: string, variant?: LoomiIconVariant | undefined) => import("lit/async-directive.js").DirectiveResult<typeof LoomiIconDirective>;
+export {};
+//# sourceMappingURL=directive.d.ts.map

package/dist/directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directive.d.ts","sourceRoot":"","sources":["../src/directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,KAAK,CAAC;AAChE,OAAO,EAAE,cAAc,EAAa,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEpF,cAAM,kBAAmB,SAAQ,cAAc;IAC7C,OAAO,CAAC,OAAO,CAAM;IAErB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,gBAA4B,GAAG,iBAAiB,GAAG,OAAO,OAAO;cAgB5E,WAAW,IAAI,IAAI;CAIvC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,uIAAgC,CAAC"}