@riebeckite/plugin-icons 0.0.0-stage → 0.0.33

package/dist/src/color.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeColor(value: unknown, options?: {
+    readonly iconicNames?: boolean;
+}): string | undefined;

package/dist/src/emoji.d.ts

@@ -0,0 +1,2 @@
+export declare function lookupEmoji(name: string): string | undefined;
+export declare function isEmoji(value: string): boolean;

package/dist/src/iconic.d.ts

@@ -0,0 +1,13 @@
+import type { IconicData, IconicRule, IconTarget } from "./types.js";
+type IconicResolution = {
+    readonly icon?: string;
+    readonly color?: string;
+    readonly rule?: string;
+};
+export type IconicDiagnosticReporter = (rule: IconicRule, message: string) => void;
+export declare function resolveIconic(data: IconicData, target: IconTarget, options: {
+    readonly colors: boolean;
+    readonly report: IconicDiagnosticReporter;
+}): IconicResolution | undefined;
+export declare function resolveIconicReference(icon: string): string;
+export {};

package/dist/src/iconize.d.ts

@@ -0,0 +1,12 @@
+import { type IconPacks } from "./settings.js";
+import type { IconizeData, IconTarget } from "./types.js";
+type IconizeResolution = {
+    readonly icon: string;
+    readonly color?: string;
+};
+export declare function resolveIconize(data: IconizeData, target: IconTarget, options: {
+    readonly colors: boolean;
+    readonly packs: IconPacks;
+}): IconizeResolution | undefined;
+export declare function parseIconReference(value: string, packNames: Iterable<string>): string | undefined;
+export {};

package/dist/src/remark.d.ts

@@ -0,0 +1,11 @@
+import type { ContentIcon } from "@riebeckite/core";
+import type { Root } from "mdast";
+type InlineIconOptions = {
+    readonly identifier: string;
+    readonly resolve: (name: string) => ContentIcon | undefined;
+};
+type SourceFile = {
+    readonly value: unknown;
+};
+export declare function remarkIcons(options: InlineIconOptions): (tree: Root, file: SourceFile) => void;
+export {};

package/dist/src/render.d.ts

@@ -0,0 +1,15 @@
+import { type ContentIcon } from "@riebeckite/core";
+import { type LoadedIconsSettings } from "./settings.js";
+import type { IconPrecedence } from "./types.js";
+type IconRenderOptions = {
+    readonly source: IconPrecedence;
+    readonly target: string;
+    readonly color?: string;
+    readonly label?: string;
+};
+export declare class IconRenderer {
+    #private;
+    constructor(settings: LoadedIconsSettings);
+    render(reference: string, options: IconRenderOptions): ContentIcon | undefined;
+}
+export {};

package/dist/src/resolve.d.ts

@@ -0,0 +1,20 @@
+import type { ConfigValidationIssue, ContentIcon, ContentManifestEntry } from "@riebeckite/core";
+import { type IconicDiagnosticReporter } from "./iconic.js";
+import { type LoadedIconsSettings } from "./settings.js";
+import type { IconsOptions, ResolvedIconsOptions } from "./types.js";
+export declare function resolveIconsOptions(options: IconsOptions | undefined): ResolvedIconsOptions;
+export declare function validateIconsOptions(options: IconsOptions | undefined): readonly ConfigValidationIssue[] | undefined;
+export type IconResolver = {
+    readonly identifier: string;
+    forEntry(entry: ContentManifestEntry): ContentIcon | undefined;
+    forFolder(folder: string): ContentIcon | undefined;
+    forTag(tag: string): ContentIcon | undefined;
+    forProperty(property: string): ContentIcon | undefined;
+    inline(name: string): ContentIcon | undefined;
+    warnings(): readonly string[];
+};
+export declare function createIconResolver(input: {
+    readonly settings: LoadedIconsSettings;
+    readonly options: ResolvedIconsOptions;
+    readonly reportRule: IconicDiagnosticReporter;
+}): IconResolver;

package/dist/src/settings.d.ts

@@ -0,0 +1,29 @@
+import { type ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import type { IconicData, IconizeData, ResolvedIconsOptions } from "./types.js";
+type IconDiagnostic = {
+    readonly code: string;
+    readonly severity: "info" | "warning";
+    readonly message: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+type IconPackFile = {
+    readonly name: string;
+    readonly filePath: string;
+    readonly size: number;
+    readonly modified: number;
+};
+export type IconPacks = ReadonlyMap<string, ReadonlyMap<string, IconPackFile>>;
+export type LoadedIconsSettings = {
+    readonly iconize?: IconizeData;
+    readonly iconic?: IconicData;
+    readonly iconPacks: IconPacks;
+    readonly iconPacksRoot?: string;
+    readonly vaultPrefix: string;
+    readonly fingerprint: string;
+    readonly diagnostics: readonly IconDiagnostic[];
+};
+export declare function loadIconsSettings(options: ResolvedIconsOptions, config: ResolvedRiebeckiteConfig | undefined): Promise<LoadedIconsSettings>;
+export declare function findIconPackFile(packs: IconPacks, packName: string, iconName: string): IconPackFile | undefined;
+export declare function normalizeIconName(name: string): string;
+export declare function normalizeVaultPath(value: string): string | undefined;
+export {};

package/dist/src/types.d.ts

@@ -0,0 +1,132 @@
+import type { ContentIcon } from "@riebeckite/core";
+export type IconSource = "iconize" | "iconic";
+export type IconPrecedence = "config" | "frontmatter" | IconSource;
+export type IconOverride = string | {
+    icon: string;
+    color?: string;
+};
+export type IconsOptions = {
+    /** Sources to read. Defaults to both Iconize and Iconic. */
+    sources?: readonly IconSource[];
+    /** Resolve colon-delimited inline icons in Markdown. Defaults to `true`. */
+    inline?: boolean;
+    /** Read the icon field from frontmatter. Defaults to `true`. */
+    frontmatter?: boolean;
+    /** Apply configured icon colors. Defaults to `true`. */
+    colors?: boolean;
+    /** Per-surface source order. Defaults to config, frontmatter, iconic, iconize. */
+    precedence?: readonly IconPrecedence[];
+    /** Explicit icons keyed by vault-relative file or folder path. */
+    overrides?: Readonly<Record<string, IconOverride>>;
+    /** Obsidian vault root. Detected from the content directory when omitted. */
+    vaultRoot?: string;
+    /** Vault path prefix for the content directory, for example `"content/"`. */
+    vaultPrefix?: string;
+    iconize?: {
+        enabled?: boolean;
+        dataFile?: string;
+        iconPacks?: string;
+    };
+    iconic?: {
+        enabled?: boolean;
+        dataFile?: string;
+    };
+};
+export type ResolvedIconsOptions = {
+    sources: readonly IconSource[];
+    inline: boolean;
+    frontmatter: boolean;
+    colors: boolean;
+    precedence: readonly IconPrecedence[];
+    overrides: Readonly<Record<string, IconOverride>>;
+    vaultRoot?: string;
+    vaultPrefix?: string;
+    iconize: {
+        enabled: boolean;
+        dataFile?: string;
+        iconPacks?: string;
+    };
+    iconic: {
+        enabled: boolean;
+        dataFile?: string;
+    };
+};
+export type IconizeSettings = {
+    iconPacksPath: string;
+    iconColor: string | null;
+    iconInFrontmatterEnabled: boolean;
+    iconInFrontmatterFieldName: string;
+    iconColorInFrontmatterFieldName: string;
+    iconsInNotesEnabled: boolean;
+    iconInLinksEnabled: boolean;
+    iconIdentifier: string;
+    lucideIconPackType: "none" | "custom" | "native";
+    emojiStyle: "native" | "twemoji";
+    rules: readonly IconizeRule[];
+};
+export type IconizeRule = {
+    rule: string;
+    icon: string;
+    order: number;
+    color?: string | null;
+    useFilePath?: boolean;
+    for?: "everything" | "files" | "folders";
+};
+export type IconizeValue = {
+    iconName: string | null;
+    iconColor?: string;
+};
+export type IconizeData = {
+    settings: IconizeSettings;
+    icons: ReadonlyMap<string, IconizeValue>;
+};
+export type IconicValue = {
+    icon?: string;
+    color?: string;
+};
+type IconicCondition = {
+    source?: string;
+    operator?: string;
+    value?: string;
+};
+export type IconicRule = {
+    id?: string;
+    name?: string;
+    icon?: string;
+    color?: string;
+    match?: "all" | "any" | "none";
+    conditions?: readonly IconicCondition[];
+    enabled?: boolean;
+};
+export type IconicData = {
+    fileIcons: Readonly<Record<string, IconicValue>>;
+    tagIcons: Readonly<Record<string, IconicValue>>;
+    propertyIcons: Readonly<Record<string, IconicValue>>;
+    fileRules: readonly IconicRule[];
+    folderRules: readonly IconicRule[];
+};
+type IconTargetKind = "file" | "folder";
+export type IconTarget = {
+    kind: IconTargetKind;
+    /** Vault-relative path. Files include their extension. */
+    path: string;
+    /** Slug for files, folder path for folders. */
+    slug: string;
+    frontmatter?: Readonly<Record<string, unknown>>;
+    tags?: readonly string[];
+    links?: readonly string[];
+    embeds?: readonly string[];
+    created?: Date;
+    modified?: Date;
+};
+export type ResolvedIconSpec = {
+    /** Namespaced icon reference, for example `lucide:rocket` or `emoji:smile`. */
+    id: string;
+    source: IconPrecedence;
+    kind: ContentIcon["kind"];
+    /** Vault path, tag, or property the icon applies to. */
+    target: string;
+    color?: string;
+    label?: string;
+};
+export {};

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@riebeckite/plugin-icons",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.33",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@riebeckite/core": "0.0.33",
+    "@types/mdast": "^4.0.4",
+    "lucide-static": "^1.61.0",
+    "sanitize-html": "^2.18.1"
+  },
+  "devDependencies": {
+    "@types/sanitize-html": "^2.16.2",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist",
+    "style.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./style.css": "./style.css"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/icons"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Obsidian Iconize and Iconic icons for Riebeckite navigation, notes, tags, and properties.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "icons",
+    "obsidian",
+    "lucide"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": [
+    "./style.css"
+  ],
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs",
+    "test": "node --import tsx --test \"test/*.test.ts\""
+  }
 }

package/style.css

@@ -0,0 +1,46 @@
+:root {
+  --rr-icon-red: var(--rb-color-danger, #c0392b);
+  --rr-icon-orange: var(--rb-color-warning, #d68910);
+  --rr-icon-yellow: var(--rb-color-warning, #b7950b);
+  --rr-icon-green: var(--rb-color-success, #1e8449);
+  --rr-icon-cyan: var(--rb-color-info, #117a8b);
+  --rr-icon-blue: var(--rb-color-info, #1f618d);
+  --rr-icon-purple: var(--rb-color-accent, #7d3c98);
+  --rr-icon-pink: var(--rb-color-accent, #a93267);
+  --rr-icon-gray: var(--rb-color-muted, #707070);
+}
+
+.rr-icon {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  width: 1em;
+  height: 1em;
+  line-height: 1;
+  vertical-align: -0.125em;
+  color: inherit;
+  overflow: visible;
+  margin-inline-end: 0.25em;
+}
+
+.rr-icon > svg {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+
+.rr-icon--emoji,
+.rr-icon--text {
+  width: auto;
+  min-width: 1em;
+  font-family:
+    "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", sans-serif;
+  font-size: 1em;
+  line-height: 1;
+  vertical-align: -0.1em;
+}
+
+.rr-icon--text {
+  font-family: inherit;
+}