@uxf/icons-generator 11.128.0 → 12.1.0

package/src/utils/_npmRegistryConfig.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._resolveRegistryTarget = _resolveRegistryTarget;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+function withTrailingSlash(url) {
+    return url.endsWith("/") ? url : `${url}/`;
+}
+/** npm identifies credentials by URL with the protocol stripped ("nerf dart"). */
+function nerfDart(url) {
+    return withTrailingSlash(url).replace(/^https?:/, "");
+}
+function collectConfigFiles(fileName) {
+    const files = [];
+    const { root } = (0, path_1.parse)(process.cwd());
+    let dir = process.cwd();
+    for (;;) {
+        const candidate = (0, path_1.join)(dir, fileName);
+        if ((0, fs_1.existsSync)(candidate)) {
+            files.push(candidate);
+        }
+        if (dir === root) {
+            break;
+        }
+        dir = (0, path_1.dirname)(dir);
+    }
+    const home = (0, path_1.join)((0, os_1.homedir)(), fileName);
+    if ((0, fs_1.existsSync)(home) && !files.includes(home)) {
+        files.push(home);
+    }
+    // Nearest file first — the first hit for any key wins.
+    return files;
+}
+function interpolateEnv(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => { var _a; return (_a = process.env[name]) !== null && _a !== void 0 ? _a : ""; });
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length > 1) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length > 1)) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseNpmrc(content) {
+    const entries = {};
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#") || line.startsWith(";") || line.startsWith("[")) {
+            continue;
+        }
+        const eq = line.indexOf("=");
+        if (eq === -1) {
+            continue;
+        }
+        const key = line.slice(0, eq).trim();
+        if (key in entries) {
+            continue;
+        }
+        entries[key] = interpolateEnv(unquote(line.slice(eq + 1)));
+    }
+    return entries;
+}
+let _npmrc;
+function npmrc() {
+    if (_npmrc) {
+        return _npmrc;
+    }
+    const merged = {};
+    for (const file of collectConfigFiles(".npmrc")) {
+        for (const [key, value] of Object.entries(parseNpmrc((0, fs_1.readFileSync)(file, "utf8")))) {
+            if (!(key in merged)) {
+                merged[key] = value;
+            }
+        }
+    }
+    _npmrc = merged;
+    return merged;
+}
+/**
+ * Split `key: value` at the separating colon, skipping colons inside quotes.
+ *
+ * `npmRegistries` is keyed by URL and Yarn writes those keys quoted, so a naive
+ * `indexOf(":")` would cut `"https://npm.uxf.dev":` after `"https` and lose both
+ * the registry and the credentials nested under it.
+ */
+function splitKeyValue(line) {
+    let quote = null;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line.charAt(index);
+        if (quote !== null) {
+            if (character === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === ":") {
+            return { key: line.slice(0, index), value: line.slice(index + 1).trim() };
+        }
+    }
+    return null;
+}
+/** Drop a trailing ` # comment`, which YAML allows after a scalar. */
+function stripInlineComment(value) {
+    if (value.startsWith('"') || value.startsWith("'")) {
+        const quote = value.charAt(0);
+        const closing = value.indexOf(quote, 1);
+        return closing === -1 ? value : value.slice(0, closing + 1);
+    }
+    const comment = value.indexOf(" #");
+    return comment === -1 ? value : value.slice(0, comment).trimEnd();
+}
+/**
+ * Indentation-only YAML reader covering the shape `.yarnrc.yml` actually uses:
+ * scalars, nested maps and quoted keys. Enough for `npmRegistryServer`,
+ * `npmScopes.*` and `npmRegistries.*`, and it keeps this package dependency-free.
+ */
+function parseSimpleYaml(content) {
+    var _a, _b, _c, _d;
+    const root = {};
+    const stack = [{ indent: -1, node: root }];
+    for (const rawLine of content.split("\n")) {
+        if (!rawLine.trim() || rawLine.trim().startsWith("#") || rawLine.trim().startsWith("-")) {
+            continue;
+        }
+        const indent = rawLine.length - rawLine.trimStart().length;
+        const pair = splitKeyValue(rawLine.trim());
+        if (!pair) {
+            continue;
+        }
+        const key = unquote(pair.key);
+        const value = stripInlineComment(pair.value);
+        while (stack.length > 1 && indent <= ((_b = (_a = stack.at(-1)) === null || _a === void 0 ? void 0 : _a.indent) !== null && _b !== void 0 ? _b : -1)) {
+            stack.pop();
+        }
+        const parent = (_d = (_c = stack.at(-1)) === null || _c === void 0 ? void 0 : _c.node) !== null && _d !== void 0 ? _d : root;
+        if (value === "" || value.startsWith("#")) {
+            const child = {};
+            parent[key] = child;
+            stack.push({ indent, node: child });
+        }
+        else {
+            parent[key] = interpolateEnv(unquote(value));
+        }
+    }
+    return root;
+}
+let _yarnrc;
+function yarnrcs() {
+    if (_yarnrc) {
+        return _yarnrc;
+    }
+    _yarnrc = collectConfigFiles(".yarnrc.yml").map((file) => parseSimpleYaml((0, fs_1.readFileSync)(file, "utf8")));
+    return _yarnrc;
+}
+function asNode(value) {
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+/* --------------------------------------------------------------- resolve */
+function authorizationFromParts(token, basic) {
+    if (token) {
+        return `Bearer ${token}`;
+    }
+    if (basic) {
+        // Yarn's `npmAuthIdent` is `user:password`; npm's `_auth` is already base64.
+        const encoded = basic.includes(":") ? Buffer.from(basic, "utf8").toString("base64") : basic;
+        return `Basic ${encoded}`;
+    }
+    return undefined;
+}
+function npmrcAuthorization(registry) {
+    const entries = npmrc();
+    // npm walks up the path of the nerf-darted registry URL looking for creds.
+    let dart = nerfDart(registry);
+    for (;;) {
+        const token = entries[`${dart}:_authToken`];
+        const auth = entries[`${dart}:_auth`];
+        const username = entries[`${dart}:username`];
+        const password = entries[`${dart}:_password`];
+        if (token || auth) {
+            return authorizationFromParts(token, auth);
+        }
+        if (username && password) {
+            const decoded = Buffer.from(password, "base64").toString("utf8");
+            return authorizationFromParts(undefined, `${username}:${decoded}`);
+        }
+        const trimmed = dart.replace(/[^/]+\/$/, "");
+        if (trimmed === dart || trimmed === "//") {
+            return undefined;
+        }
+        dart = trimmed;
+    }
+}
+function yarnrcRegistryNode(config, registry) {
+    var _a;
+    const registries = asNode(config.npmRegistries);
+    if (!registries) {
+        return undefined;
+    }
+    // Yarn matches `npmRegistries` keys with or without the trailing slash.
+    const withSlash = withTrailingSlash(registry);
+    const withoutSlash = withSlash.slice(0, -1);
+    return (_a = asNode(registries[withSlash])) !== null && _a !== void 0 ? _a : asNode(registries[withoutSlash]);
+}
+function yarnAuthorization(scope, registry) {
+    var _a;
+    for (const config of yarnrcs()) {
+        const scopeNode = asNode((_a = asNode(config.npmScopes)) === null || _a === void 0 ? void 0 : _a[scope]);
+        const registryNode = yarnrcRegistryNode(config, registry);
+        // The top-level credential belongs to the top-level registry and to
+        // nothing else. Yarn scopes it the same way, and using it as a blanket
+        // fallback would hand our Verdaccio token to whatever host a scope
+        // happens to point at — Font Awesome's own registry, for instance.
+        const rootRegistry = asString(config.npmRegistryServer);
+        const rootNode = rootRegistry !== undefined && withTrailingSlash(rootRegistry) === withTrailingSlash(registry)
+            ? config
+            : undefined;
+        for (const node of [scopeNode, registryNode, rootNode]) {
+            if (!node) {
+                continue;
+            }
+            const authorization = authorizationFromParts(asString(node.npmAuthToken), asString(node.npmAuthIdent));
+            if (authorization) {
+                return authorization;
+            }
+        }
+    }
+    return undefined;
+}
+function resolveRegistry(scope) {
+    var _a, _b, _c;
+    const fromNpmrc = (_a = npmrc()[`@${scope}:registry`]) !== null && _a !== void 0 ? _a : undefined;
+    if (fromNpmrc) {
+        return withTrailingSlash(fromNpmrc);
+    }
+    for (const config of yarnrcs()) {
+        const scoped = asString((_c = asNode((_b = asNode(config.npmScopes)) === null || _b === void 0 ? void 0 : _b[scope])) === null || _c === void 0 ? void 0 : _c.npmRegistryServer);
+        if (scoped) {
+            return withTrailingSlash(scoped);
+        }
+    }
+    const npmDefault = npmrc().registry;
+    if (npmDefault) {
+        return withTrailingSlash(npmDefault);
+    }
+    for (const config of yarnrcs()) {
+        const fallback = asString(config.npmRegistryServer);
+        if (fallback) {
+            return withTrailingSlash(fallback);
+        }
+    }
+    return DEFAULT_REGISTRY;
+}
+/**
+ * Work out which registry serves a scoped package and how to authenticate
+ * against it, reading the same `.npmrc` / `.yarnrc.yml` files the package
+ * manager would. Consumer projects are on Yarn while this monorepo is on npm,
+ * so both have to be understood.
+ */
+function _resolveRegistryTarget(packageName) {
+    var _a, _b;
+    const scope = packageName.startsWith("@") ? ((_a = packageName.slice(1).split("/").at(0)) !== null && _a !== void 0 ? _a : "") : "";
+    const registry = resolveRegistry(scope);
+    return {
+        authorization: (_b = npmrcAuthorization(registry)) !== null && _b !== void 0 ? _b : yarnAuthorization(scope, registry),
+        registry,
+    };
+}

package/src/utils/_parseFaSvg.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedFaSvg {
+    width: number;
+    height: number;
+    pathData: string | string[];
+}
+export declare function _parseFaSvg(svgContent: string): ParsedFaSvg;

package/src/utils/_parseFaSvg.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._parseFaSvg = _parseFaSvg;
+const VIEW_BOX_RE = /viewBox="0\s+0\s+(\d+)\s+(\d+)"/;
+const PATH_D_RE = /<path\b[^>]*\sd="([^"]*)"/g;
+function _parseFaSvg(svgContent) {
+    const viewBox = svgContent.match(VIEW_BOX_RE);
+    if (!viewBox) {
+        throw new Error("Could not find a viewBox starting at the origin in SVG content.");
+    }
+    const paths = [...svgContent.matchAll(PATH_D_RE)].map((match) => { var _a; return (_a = match.at(1)) !== null && _a !== void 0 ? _a : ""; });
+    if (paths.length === 0) {
+        throw new Error("No <path d=...> elements found in SVG content.");
+    }
+    const single = paths.at(0);
+    return {
+        width: Number(viewBox.at(1)),
+        height: Number(viewBox.at(2)),
+        pathData: paths.length === 1 && single !== undefined ? single : paths,
+    };
+}

package/src/utils/_prefetchRegistry.d.ts

@@ -0,0 +1,18 @@
+type Prefetch = () => Promise<void>;
+/**
+ * Providers register here as they are loaded, which only happens when a
+ * project's `icons.config.js` actually requires one.
+ *
+ * The indirection keeps the CLI from importing any provider itself: a config
+ * built purely from inline SVGs must not pay for — or be broken by — a
+ * provider's module-level setup, such as the `faPro` adapter refusing to run
+ * while the retired `@fortawesome/fontawesome-pro` monolith is installed.
+ */
+export declare function _registerPrefetch(prefetch: Prefetch): void;
+/**
+ * Let every loaded provider resolve its icons up front. Providers expose a
+ * synchronous per-icon API, so anything needing I/O has to be fetched here,
+ * between loading the config and generating the sprite.
+ */
+export declare function _runPrefetch(): Promise<void>;
+export {};

package/src/utils/_prefetchRegistry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._registerPrefetch = _registerPrefetch;
+exports._runPrefetch = _runPrefetch;
+const prefetchers = new Set();
+/**
+ * Providers register here as they are loaded, which only happens when a
+ * project's `icons.config.js` actually requires one.
+ *
+ * The indirection keeps the CLI from importing any provider itself: a config
+ * built purely from inline SVGs must not pay for — or be broken by — a
+ * provider's module-level setup, such as the `faPro` adapter refusing to run
+ * while the retired `@fortawesome/fontawesome-pro` monolith is installed.
+ */
+function _registerPrefetch(prefetch) {
+    prefetchers.add(prefetch);
+}
+/**
+ * Let every loaded provider resolve its icons up front. Providers expose a
+ * synchronous per-icon API, so anything needing I/O has to be fetched here,
+ * between loading the config and generating the sprite.
+ */
+async function _runPrefetch() {
+    await Promise.all([...prefetchers].map((prefetch) => prefetch()));
+}

package/src/utils/_untar.d.ts

@@ -0,0 +1,16 @@
+export interface TarEntry {
+    content: Uint8Array<ArrayBuffer>;
+    name: string;
+}
+/**
+ * Minimal streaming tar reader.
+ *
+ * Yields only the entries `wants` accepts, so the caller never has to hold the
+ * whole archive: everything else is consumed and dropped as it arrives. That is
+ * what lets us pull a ~110 MB Font Awesome tarball over the network and keep
+ * just the handful of SVGs a project actually references.
+ *
+ * Breaking out of the loop cancels the underlying stream, so a caller that has
+ * everything it needs stops the download instead of draining it.
+ */
+export declare function _untar(stream: ReadableStream<Uint8Array>, wants: (name: string) => boolean): AsyncGenerator<TarEntry>;

package/src/utils/_untar.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._untar = _untar;
+const BLOCK_SIZE = 512;
+const NAME_OFFSET = 0;
+const NAME_LENGTH = 100;
+const SIZE_OFFSET = 124;
+const SIZE_LENGTH = 12;
+const TYPEFLAG_OFFSET = 156;
+const PREFIX_OFFSET = 345;
+const PREFIX_LENGTH = 155;
+const decoder = new TextDecoder();
+function readString(header, offset, length) {
+    const raw = header.subarray(offset, offset + length);
+    const end = raw.indexOf(0);
+    return decoder.decode(end === -1 ? raw : raw.subarray(0, end)).trim();
+}
+// tar stores the size as a NUL/space terminated octal string. GNU also emits a
+// base-256 form for sizes that do not fit in 11 octal digits; no entry in the
+// Font Awesome tarballs is anywhere near 8 GB, so the octal form is enough.
+function readSize(header) {
+    const raw = readString(header, SIZE_OFFSET, SIZE_LENGTH);
+    const parsed = Number.parseInt(raw, 8);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function isZeroBlock(block) {
+    return block.every((byte) => byte === 0);
+}
+function concat(left, right) {
+    const out = new Uint8Array(left.length + right.length);
+    out.set(left, 0);
+    out.set(right, left.length);
+    return out;
+}
+/** A GNU "L" entry's payload is the replacement path, NUL terminated. */
+function readGnuLongName(payload) {
+    const end = payload.indexOf(0);
+    const value = decoder.decode(end === -1 ? payload : payload.subarray(0, end)).trim();
+    return value === "" ? null : value;
+}
+const SPACE = 0x20;
+const EQUALS = 0x3d;
+/**
+ * A pax extended header's payload is a sequence of `"<len> <key>=<value>\n"`
+ * records, where `<len>` counts its own digits too. Only `path` interests us;
+ * everything else (mtime, sizes, ownership) is metadata we do not read.
+ *
+ * The walk is over bytes, not over a decoded string: `<len>` is a byte count,
+ * and a single non-ASCII character in an earlier record (an accented `uname`,
+ * say) would otherwise shift every subsequent offset and silently lose the
+ * path — which is the very truncation this exists to prevent.
+ */
+function readPaxPath(payload) {
+    let offset = 0;
+    while (offset < payload.length) {
+        const space = payload.indexOf(SPACE, offset);
+        if (space === -1) {
+            return null;
+        }
+        const recordLength = Number.parseInt(decoder.decode(payload.subarray(offset, space)), 10);
+        if (!Number.isFinite(recordLength) || recordLength <= 0 || offset + recordLength > payload.length) {
+            return null;
+        }
+        const record = payload.subarray(space + 1, offset + recordLength);
+        const equals = record.indexOf(EQUALS);
+        if (equals !== -1 && decoder.decode(record.subarray(0, equals)) === "path") {
+            // The record ends with the newline its length accounts for.
+            return decoder.decode(record.subarray(equals + 1)).replace(/\n$/, "");
+        }
+        offset += recordLength;
+    }
+    return null;
+}
+/**
+ * Minimal streaming tar reader.
+ *
+ * Yields only the entries `wants` accepts, so the caller never has to hold the
+ * whole archive: everything else is consumed and dropped as it arrives. That is
+ * what lets us pull a ~110 MB Font Awesome tarball over the network and keep
+ * just the handful of SVGs a project actually references.
+ *
+ * Breaking out of the loop cancels the underlying stream, so a caller that has
+ * everything it needs stops the download instead of draining it.
+ */
+async function* _untar(stream, wants) {
+    var _a;
+    const reader = stream.getReader();
+    let buffer = new Uint8Array(0);
+    let isStreamDone = false;
+    const pull = async () => {
+        const { done: isDone, value } = await reader.read();
+        if (isDone) {
+            isStreamDone = true;
+            return;
+        }
+        buffer = concat(buffer, value);
+    };
+    const ensure = async (length) => {
+        while (buffer.length < length && !isStreamDone) {
+            await pull();
+        }
+        return buffer.length >= length;
+    };
+    const take = (length) => {
+        const out = buffer.subarray(0, length);
+        buffer = buffer.subarray(length);
+        return out;
+    };
+    const skip = async (length) => {
+        let remaining = length;
+        while (remaining > 0) {
+            if (buffer.length === 0) {
+                if (isStreamDone) {
+                    return false;
+                }
+                await pull();
+                continue;
+            }
+            const chunk = Math.min(remaining, buffer.length);
+            buffer = buffer.subarray(chunk);
+            remaining -= chunk;
+        }
+        return true;
+    };
+    // Set by a preceding GNU long-name ("L") or pax ("x") entry and consumed by
+    // the next real entry, whose own 100-byte name field is then a truncated
+    // duplicate. npm's own packer emits the pax form, so both have to work —
+    // ignoring them would index an icon under a silently truncated name.
+    let pendingLongName = null;
+    // Running out of data is never a normal ending: a tar archive finishes with
+    // a zero-filled block. Treating exhaustion as "done" would let a cut
+    // download look like a complete but much smaller archive, and the caller
+    // would cache that partial reading as authoritative.
+    const truncated = () => new Error("Unexpected end of tar archive — the download was cut short.");
+    try {
+        for (;;) {
+            if (!(await ensure(BLOCK_SIZE))) {
+                throw truncated();
+            }
+            const header = take(BLOCK_SIZE);
+            if (isZeroBlock(header)) {
+                return;
+            }
+            const size = readSize(header);
+            const padded = Math.ceil(size / BLOCK_SIZE) * BLOCK_SIZE;
+            const typeFlag = String.fromCharCode((_a = header.at(TYPEFLAG_OFFSET)) !== null && _a !== void 0 ? _a : 0);
+            if (typeFlag === "L" || typeFlag === "x" || typeFlag === "g") {
+                if (!(await ensure(padded))) {
+                    throw truncated();
+                }
+                const payload = take(padded).subarray(0, size);
+                const overridden = typeFlag === "L" ? readGnuLongName(payload) : readPaxPath(payload);
+                // A global ("g") header carries defaults for the rest of the
+                // archive rather than for one entry; it never names a path, so
+                // in practice this leaves `pendingLongName` untouched.
+                if (overridden !== null) {
+                    pendingLongName = overridden;
+                }
+                continue;
+            }
+            const prefix = readString(header, PREFIX_OFFSET, PREFIX_LENGTH);
+            const shortName = readString(header, NAME_OFFSET, NAME_LENGTH);
+            const name = pendingLongName !== null && pendingLongName !== void 0 ? pendingLongName : (prefix ? `${prefix}/${shortName}` : shortName);
+            pendingLongName = null;
+            const isFile = typeFlag === "0" || typeFlag === "\0";
+            if (!isFile || !wants(name)) {
+                if (!(await skip(padded))) {
+                    throw truncated();
+                }
+                continue;
+            }
+            if (!(await ensure(padded))) {
+                throw truncated();
+            }
+            // Copy out of the shared buffer — `subarray` would keep the whole
+            // backing chunk alive for as long as the caller holds the entry.
+            yield { content: new Uint8Array(take(padded).subarray(0, size)), name };
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+}