@wisdomgarden/torque-icons 0.1.0

package/dist/icon.js

@@ -0,0 +1,55 @@
+import { jsx as t } from "react/jsx-runtime";
+import { Suspense as d, createElement as p, lazy as u } from "react";
+import { loadIcon as f } from "./loader.js";
+import { getIconLoader as m } from "./registry.js";
+const c = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ (() => {
+  const e = /* @__PURE__ */ new Set();
+  return (r, n) => {
+    e.has(r) || (e.add(r), console.warn(
+      `[@wisdomgarden/torque-icons] Failed to load icon "${r}".`,
+      n
+    ));
+  };
+})(), w = (e) => {
+  let r = c.get(e);
+  if (!r) {
+    const n = m() ?? f;
+    r = u(async () => {
+      try {
+        return { default: await n(e) };
+      } catch (o) {
+        return y(e, o), { default: () => null };
+      }
+    }), c.set(e, r);
+  }
+  return r;
+}, I = ({
+  name: e,
+  useOriginalColor: r,
+  width: n = "1em",
+  height: o = "1em",
+  style: l,
+  ref: a,
+  ...s
+}) => {
+  const i = w(e);
+  return /* @__PURE__ */ t(
+    "span",
+    {
+      ...s,
+      ref: a,
+      "data-icon-name": e,
+      style: { display: "inline-flex", ...l },
+      children: /* @__PURE__ */ t(
+        d,
+        {
+          fallback: /* @__PURE__ */ t("span", { style: { display: "inline-block", width: n, height: o } }),
+          children: p(i, { useOriginalColor: r, width: n, height: o })
+        }
+      )
+    }
+  );
+};
+export {
+  I as Icon
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Icon } from './icon';
+export { getIconLoader, setIconLoader } from './registry';
+export { iconNames } from './icon-names';
+export type { IconLoader, IconName, IconNameLiteral, IconProps, IconSvgComponent, IconSvgProps, } from './types';

package/dist/index.js

@@ -0,0 +1,9 @@
+import { Icon as r } from "./icon.js";
+import { getIconLoader as c, setIconLoader as m } from "./registry.js";
+import { iconNames as a } from "./icon-names.js";
+export {
+  r as Icon,
+  c as getIconLoader,
+  a as iconNames,
+  m as setIconLoader
+};

package/dist/loader.d.ts

@@ -0,0 +1,8 @@
+import { IconSvgComponent } from './types';
+/**
+ * The dynamic import lives inside the package so a host never has to write one
+ * itself. Its prefix is static and only the name varies, which is what lets a
+ * bundler build a context module over `./generated/` and emit one chunk per
+ * icon — a page then downloads only the icons it actually renders.
+ */
+export declare const loadIcon: (name: string) => Promise<IconSvgComponent>;

package/dist/loader.js

@@ -0,0 +1,17 @@
+const o = (e) => (
+  // `@vite-ignore` keeps this package's own build from touching the expression.
+  // Vite would otherwise hand it to @rollup/plugin-dynamic-import-vars, which
+  // resolves variable imports at build time into a static map — here that map
+  // comes out empty (the icons are separate entries), so every call would throw
+  // `Unknown variable dynamic import`, and that plugin only supports one path
+  // segment anyway while names like `file/document` have two.
+  import(
+    /* @vite-ignore */
+    `./generated/${e}.js`
+  ).then(
+    (t) => t.default
+  )
+);
+export {
+  o as loadIcon
+};

package/dist/registry.d.ts

@@ -0,0 +1,20 @@
+import { IconLoader } from './types';
+/**
+ * Optional. `<Icon>` already resolves names through the bundled loader, which
+ * splits this package's icon directory into one chunk per icon — nothing needs
+ * registering for that to work.
+ *
+ * Register one only to change where icons come from entirely: a CDN, or a host
+ * that keeps its own icon set.
+ *
+ * ```ts
+ * setIconLoader(name => fetchMyIcon(name));
+ * ```
+ *
+ * Must be called before the first `<Icon>` renders — resolved components are
+ * cached per name. Module-level state, so the package has to be a single
+ * instance; that is why it is a peerDependency of `@wisdomgarden/torque` rather
+ * than a dependency.
+ */
+export declare const setIconLoader: (loader: IconLoader | undefined) => void;
+export declare const getIconLoader: () => IconLoader | undefined;

package/dist/registry.js

@@ -0,0 +1,8 @@
+let o;
+const t = (e) => {
+  o = e;
+}, c = () => o;
+export {
+  c as getIconLoader,
+  t as setIconLoader
+};

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import { ComponentPropsWithoutRef, ComponentType, Ref, SVGProps } from 'react';
+import type { IconNameLiteral } from './icon-names';
+export type { IconNameLiteral };
+/**
+ * Autocompletes every shipped name while still accepting any string, because a
+ * name is frequently computed at runtime (`file/${upload.type}`) or comes
+ * straight from the backend. `IconNameLiteral` is the strict union for the rare
+ * caller that wants exhaustiveness.
+ */
+export type IconName = IconNameLiteral | (string & {});
+export type IconSvgProps = SVGProps<SVGSVGElement> & {
+    readonly useOriginalColor?: boolean;
+};
+export type IconSvgComponent = ComponentType<IconSvgProps>;
+/** Resolves an icon name to its component. See `./loader` for the bundled one. */
+export type IconLoader = (name: string) => Promise<IconSvgComponent>;
+export interface IconProps extends Omit<ComponentPropsWithoutRef<'span'>, 'width' | 'height'> {
+    readonly name: IconName;
+    /**
+     * Render the icon with the colors it was drawn with instead of letting it
+     * inherit `currentColor`. Required for icons that carry their own palette —
+     * a filled background plus white glyphs, brand logos, gradients — without it
+     * every shape collapses to a single color.
+     */
+    readonly useOriginalColor?: boolean;
+    readonly width?: string | number;
+    readonly height?: string | number;
+    readonly ref?: Ref<HTMLSpanElement>;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@wisdomgarden/torque-icons",
+  "version": "0.1.0",
+  "description": "Torque Design icons — the Wisdom Garden icon set — one lazily loaded ES module per icon, plus a React <Icon> that resolves them by name.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.ts",
+      "default": "./dist/loader.js"
+    },
+    "./generated/*": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/generated/*"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "react": "^19"
+  },
+  "devDependencies": {
+    "@svgr/core": "^8.1.0",
+    "@svgr/plugin-jsx": "^8.1.0",
+    "@types/react": "^19.2.18",
+    "react": "^19.2.8",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "generate": "node scripts/generate.mjs",
+    "build": "pnpm generate && vite build && tsc -p tsconfig.build.json && node scripts/strip-generated-sourcemaps.mjs",
+    "type:check": "tsc -p tsconfig.json"
+  }
+}