@lapis-notes/api 0.1.0

package/dist/links.js

@@ -0,0 +1,191 @@
+import { basename, dirname } from "./storage/path";
+import { stripHeadingForLink } from "./utils";
+export const defaultLinkSettings = {
+    newLinkFormat: "shortest",
+    useWikilinks: true,
+    omitMarkdownExtension: true,
+    useShortestUniqueSuffix: false,
+};
+function splitVaultPath(path) {
+    return normalizeVaultPath(path).split("/").filter(Boolean);
+}
+function isMarkdownExtension(extension) {
+    return /^(md|markdown)$/i.test(extension);
+}
+function getFileExtension(path) {
+    const name = basename(normalizeVaultPath(path));
+    const lastDot = name.lastIndexOf(".");
+    if (lastDot <= 0) {
+        return "";
+    }
+    return name.slice(lastDot + 1);
+}
+function getFileBasename(path) {
+    const name = basename(normalizeVaultPath(path));
+    const lastDot = name.lastIndexOf(".");
+    if (lastDot <= 0) {
+        return name;
+    }
+    return name.slice(0, lastDot);
+}
+function getMarkdownBasename(path) {
+    return basename(normalizeVaultPath(path)).replace(/\.(md|markdown)$/i, "");
+}
+function getPathSuffix(path, segmentCount) {
+    const parts = splitVaultPath(path);
+    return parts.slice(-segmentCount).join("/");
+}
+function getSourceDirectory(sourcePath) {
+    const normalized = normalizeVaultPath(sourcePath);
+    if (!normalized.length) {
+        return "";
+    }
+    const directory = dirname(normalized);
+    return directory === "/" ? "" : normalizeVaultPath(directory);
+}
+function applyMarkdownExtensionPreference(path, settings) {
+    if (!settings.omitMarkdownExtension) {
+        return path;
+    }
+    return normalizeVaultPath(path).replace(/\.(md|markdown)$/i, "");
+}
+function getAbsoluteLinkPath(targetPath, settings) {
+    return applyMarkdownExtensionPreference(targetPath, settings);
+}
+function getRelativeLinkPath(targetPath, sourcePath, settings) {
+    const targetParts = splitVaultPath(targetPath);
+    const sourceParts = splitVaultPath(getSourceDirectory(sourcePath));
+    let sharedLength = 0;
+    while (sharedLength < sourceParts.length &&
+        sharedLength < targetParts.length &&
+        sourceParts[sharedLength] === targetParts[sharedLength]) {
+        sharedLength += 1;
+    }
+    const relativeParts = [
+        ...sourceParts.slice(sharedLength).map(() => ".."),
+        ...targetParts.slice(sharedLength),
+    ];
+    const relativePath = relativeParts.join("/");
+    return applyMarkdownExtensionPreference(relativePath, settings);
+}
+function getObsidianCompatibleShortestPath(targetPath, settings, vaultIndex) {
+    const normalizedTarget = normalizeVaultPath(targetPath);
+    const targetExtension = getFileExtension(normalizedTarget);
+    const targetBase = isMarkdownExtension(targetExtension)
+        ? getMarkdownBasename(normalizedTarget)
+        : getFileBasename(normalizedTarget);
+    const matches = vaultIndex
+        .getFiles()
+        .filter((file) => file.basename === targetBase &&
+        file.extension.toLowerCase() === targetExtension.toLowerCase());
+    if (matches.length === 1) {
+        if (!targetExtension) {
+            return targetBase;
+        }
+        return applyMarkdownExtensionPreference(`${targetBase}.${targetExtension}`, settings);
+    }
+    return getAbsoluteLinkPath(normalizedTarget, settings);
+}
+function getShortestUniqueSuffixPath(targetPath, settings, vaultIndex) {
+    const normalizedTarget = normalizeVaultPath(targetPath);
+    const targetExtension = getFileExtension(normalizedTarget);
+    const targetBase = isMarkdownExtension(targetExtension)
+        ? getMarkdownBasename(normalizedTarget)
+        : getFileBasename(normalizedTarget);
+    const matches = vaultIndex
+        .getFiles()
+        .filter((file) => file.basename === targetBase &&
+        file.extension.toLowerCase() === targetExtension.toLowerCase());
+    if (matches.length <= 1) {
+        return getObsidianCompatibleShortestPath(normalizedTarget, settings, vaultIndex);
+    }
+    const targetParts = splitVaultPath(normalizedTarget);
+    for (let segmentCount = 1; segmentCount <= targetParts.length; segmentCount += 1) {
+        const suffix = getPathSuffix(normalizedTarget, segmentCount);
+        const collisions = matches.filter((file) => getPathSuffix(file.path, segmentCount) === suffix);
+        if (collisions.length === 1) {
+            return applyMarkdownExtensionPreference(suffix, settings);
+        }
+    }
+    return getAbsoluteLinkPath(normalizedTarget, settings);
+}
+function getResolvedSettings(settings) {
+    return {
+        ...defaultLinkSettings,
+        ...settings,
+    };
+}
+function getLabelFromTargetPath(targetPath) {
+    const normalized = normalizeVaultPath(targetPath);
+    const extension = getFileExtension(normalized);
+    if (isMarkdownExtension(extension)) {
+        return getMarkdownBasename(normalized);
+    }
+    return basename(normalized);
+}
+function getLinkFragment(options) {
+    if (options.blockId?.trim()) {
+        return `#^${options.blockId.trim()}`;
+    }
+    if (options.heading?.trim()) {
+        return `#${stripHeadingForLink(options.heading)}`;
+    }
+    return "";
+}
+function escapeRegexChar(char) {
+    return `\\${char}`;
+}
+export function normalizeVaultPath(path) {
+    return path.replaceAll("\\", "/").replace(/^\/+/, "").replace(/\/$/, "");
+}
+export function escapeWikilinkPath(path) {
+    return path.replace(/[\\#[\]|]/g, escapeRegexChar);
+}
+export function escapeWikilinkAlias(alias) {
+    return alias.replace(/[\\[\]|]/g, escapeRegexChar);
+}
+export function encodeMarkdownLinkDestination(path) {
+    const [rawPath, rawFragment] = path.split("#", 2);
+    const encodedPath = splitVaultPath(rawPath)
+        .map((part) => encodeURIComponent(part))
+        .join("/");
+    if (rawFragment === undefined) {
+        return encodedPath;
+    }
+    return `${encodedPath}#${encodeURIComponent(rawFragment)}`;
+}
+export function escapeMarkdownLabel(label) {
+    return label.replace(/[\\\[\]]/g, escapeRegexChar);
+}
+export function getLinkPath(targetPath, sourcePath, settings, vaultIndex) {
+    const normalizedTarget = normalizeVaultPath(targetPath);
+    const normalizedSource = normalizeVaultPath(sourcePath);
+    switch (settings.newLinkFormat) {
+        case "absolute":
+            return getAbsoluteLinkPath(normalizedTarget, settings);
+        case "relative":
+            return getRelativeLinkPath(normalizedTarget, normalizedSource, settings);
+        case "shortest":
+        default:
+            if (settings.useShortestUniqueSuffix) {
+                return getShortestUniqueSuffixPath(normalizedTarget, settings, vaultIndex);
+            }
+            return getObsidianCompatibleShortestPath(normalizedTarget, settings, vaultIndex);
+    }
+}
+export function generateInternalLink(options) {
+    const settings = getResolvedSettings(options.settings);
+    const targetPath = normalizeVaultPath(options.targetPath);
+    const linkPath = getLinkPath(targetPath, options.sourcePath, settings, options.vaultIndex ?? { getFiles: () => [] });
+    const fragment = getLinkFragment(options);
+    if (settings.useWikilinks) {
+        const target = `${escapeWikilinkPath(linkPath)}${fragment}`;
+        const alias = options.alias?.trim();
+        const display = alias ? `|${escapeWikilinkAlias(alias)}` : "";
+        return `${options.embed ? "!" : ""}[[${target}${display}]]`;
+    }
+    const alias = options.alias?.trim();
+    const label = escapeMarkdownLabel(alias || getLabelFromTargetPath(targetPath));
+    const destination = encodeMarkdownLinkDestination(`${linkPath}${fragment}`);
+    return `${options.embed ? "!" : ""}[${label}](${destination})`;
+}

package/dist/loaders.d.ts

@@ -0,0 +1,9 @@
+export declare function getLanguage(): string;
+export declare function loadMathJax(): Promise<void>;
+export declare function loadMermaid(): Promise<any>;
+export declare function loadPdfJs(): Promise<any>;
+export declare function loadPrism(): Promise<any>;
+export declare function renderMath(source: string, display: boolean): HTMLElement;
+export declare function finishRenderMath(): void;
+export declare function sanitizeHTMLString(html: string): string;
+export declare function sanitizeHTMLToDom(html: string): DocumentFragment;

package/dist/loaders.js

@@ -0,0 +1,59 @@
+export function getLanguage() {
+    return navigator.language || "en";
+}
+export async function loadMathJax() { }
+export async function loadMermaid() {
+    return globalThis.mermaid ?? {};
+}
+export async function loadPdfJs() {
+    return globalThis.pdfjsLib ?? {};
+}
+export async function loadPrism() {
+    return globalThis.Prism ?? {};
+}
+export function renderMath(source, display) {
+    const el = document.createElement(display ? "div" : "span");
+    el.className = display ? "math math-block" : "math math-inline";
+    el.textContent = source;
+    return el;
+}
+export function finishRenderMath() { }
+const unsafeElementSelector = "script, iframe, object, embed";
+const urlAttributes = new Set([
+    "href",
+    "src",
+    "xlink:href",
+    "formaction",
+    "poster",
+]);
+function isUnsafeUrl(value) {
+    return /^\s*(?:javascript:|vbscript:|data:text\/html)/i.test(value);
+}
+function sanitizeDomTree(root) {
+    root
+        .querySelectorAll(unsafeElementSelector)
+        .forEach((element) => element.remove());
+    root.querySelectorAll("*").forEach((element) => {
+        for (const attr of [...element.attributes]) {
+            const name = attr.name.toLowerCase();
+            if (name.startsWith("on")) {
+                element.removeAttribute(attr.name);
+            }
+            else if (urlAttributes.has(name) && isUnsafeUrl(attr.value)) {
+                element.removeAttribute(attr.name);
+            }
+        }
+    });
+}
+export function sanitizeHTMLString(html) {
+    return html
+        .replace(/<\s*(script|iframe|object|embed)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>/gi, "")
+        .replace(/\s+on[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "")
+        .replace(/\s+(href|src|xlink:href|formaction|poster)\s*=\s*(["']?)\s*(?:javascript:|vbscript:|data:text\/html)[\s\S]*?\2/gi, "");
+}
+export function sanitizeHTMLToDom(html) {
+    const template = document.createElement("template");
+    template.innerHTML = sanitizeHTMLString(html);
+    sanitizeDomTree(template.content);
+    return template.content;
+}

package/dist/localization-manager.svelte.d.ts

@@ -0,0 +1,56 @@
+export interface LocaleData {
+    [key: string]: string | LocaleData;
+}
+export interface I18nConfig {
+    defaultLocale: string;
+    locales: string[];
+    fallbackLocale?: string;
+    interpolation?: {
+        prefix?: string;
+        suffix?: string;
+        escapeValue?: boolean;
+    };
+    debug?: boolean;
+}
+type TranslateArgs = [namespace: string, key: string, params?: Record<string, string | number>] | [key: string, params?: Record<string, string | number>];
+export declare class LocalizationManager {
+    private currentLocale;
+    private initialized;
+    private availableLocales;
+    constructor();
+    get locale(): string;
+    get locales(): string[];
+    get instance(): import("i18next").i18n;
+    private initializeI18next;
+    setConfig(config: Partial<I18nConfig>): Promise<void>;
+    setLocale(locale: string): Promise<void>;
+    addResourceBundle(ns: string, locale: string, translations: LocaleData, deep?: boolean, overwrite?: boolean): Promise<() => void>;
+    private extractParams;
+    t(namespace: string, key: string, params?: Record<string, string | number>): string;
+    t(namespace: string, key: string): string;
+    t(key: string, params?: Record<string, string | number>): string;
+    t(...args: TranslateArgs): string;
+    plural(count: number, namespace: string, key: string, params?: Record<string, string | number>): string;
+    plural(count: number, namespace: string, key: string): string;
+    plural(count: number, key: string, params?: Record<string, string | number>): string;
+    plural(count: number, ...args: TranslateArgs): string;
+    exists(key: string, locale?: string, namespace?: string): boolean;
+}
+declare const localeManager: LocalizationManager;
+declare const t: {
+    (namespace: string, key: string, params?: Record<string, string | number>): string;
+    (namespace: string, key: string): string;
+    (key: string, params?: Record<string, string | number>): string;
+    (...args: TranslateArgs): string;
+};
+declare const plural: {
+    (count: number, namespace: string, key: string, params?: Record<string, string | number>): string;
+    (count: number, namespace: string, key: string): string;
+    (count: number, key: string, params?: Record<string, string | number>): string;
+    (count: number, ...args: TranslateArgs): string;
+};
+export declare function useLocale(namespace?: string): {
+    t(key: string, params?: Record<string, string | number>): string;
+    plural(key: string, count: number, params?: Record<string, string | number>): string;
+};
+export { localeManager, localeManager as i18n, t, plural };

package/dist/localization-manager.svelte.js

@@ -0,0 +1,157 @@
+import i18next, {} from "i18next";
+export class LocalizationManager {
+    currentLocale = $state("en");
+    initialized = false;
+    availableLocales = $state(["en"]);
+    constructor() {
+        this.initializeI18next();
+    }
+    get locale() {
+        return this.currentLocale;
+    }
+    get locales() {
+        return this.availableLocales;
+    }
+    get instance() {
+        return i18next;
+    }
+    async initializeI18next() {
+        const config = {
+            lng: "en",
+            fallbackLng: "en",
+            debug: false,
+            interpolation: {
+                escapeValue: false,
+                prefix: "{{",
+                suffix: "}}",
+            },
+            resources: {},
+            defaultNS: "base",
+            ns: ["base"],
+            returnEmptyString: false,
+            returnNull: false,
+            returnObjects: false,
+            keySeparator: ".",
+            nsSeparator: ":",
+        };
+        await i18next.init(config);
+        this.initialized = true;
+        this.currentLocale = i18next.language;
+    }
+    async setConfig(config) {
+        if (!this.initialized) {
+            await this.initializeI18next();
+        }
+        const i18nextConfig = {
+            lng: config.defaultLocale,
+            fallbackLng: config.fallbackLocale || config.defaultLocale,
+            debug: config.debug || false,
+            interpolation: config.interpolation
+                ? {
+                    escapeValue: config.interpolation.escapeValue ?? false,
+                    prefix: config.interpolation.prefix || "{{",
+                    suffix: config.interpolation.suffix || "}}",
+                }
+                : undefined,
+        };
+        await i18next.init(i18nextConfig);
+        if (config.locales) {
+            this.availableLocales = config.locales;
+        }
+        if (config.defaultLocale) {
+            this.currentLocale = config.defaultLocale;
+        }
+    }
+    async setLocale(locale) {
+        if (!this.availableLocales.includes(locale)) {
+            console.warn(`Locale ${locale} not supported. Available locales: ${this.availableLocales.join(", ")}`);
+            return;
+        }
+        await i18next.changeLanguage(locale);
+        this.currentLocale = locale;
+    }
+    async addResourceBundle(ns, locale, translations, deep = true, overwrite = true) {
+        if (!this.initialized) {
+            await this.initializeI18next();
+        }
+        i18next.addResourceBundle(locale, ns, translations, deep, overwrite);
+        return () => {
+            i18next.removeResourceBundle(locale, ns);
+            const currentNamespaces = i18next.options.ns;
+            i18next.options.ns = currentNamespaces.filter((namespace) => namespace !== ns);
+        };
+    }
+    extractParams(...args) {
+        let key;
+        let namespace;
+        let params;
+        if (typeof args[0] !== "string") {
+            throw new Error("Expected a string as the first argument in i18n.t");
+        }
+        if (args.length === 3) {
+            if (typeof args[1] !== "string") {
+                throw new Error("Expected a string as the second argument for key in i18n.t");
+            }
+            namespace = args[0];
+            key = args[1];
+            params = args[2];
+        }
+        else if (args.length == 2) {
+            if (typeof args[1] === "string") {
+                namespace = args[0];
+                key = args[1];
+            }
+            else if (typeof args[1] === "object") {
+                key = args[0];
+                params = args[1];
+            }
+            else {
+                throw new Error("Expected a string | object as the second argument in i18n.t");
+            }
+        }
+        else {
+            key = args[0];
+        }
+        return [key, namespace, params];
+    }
+    t(...args) {
+        const [key, namespace, params] = this.extractParams(...args);
+        const id = namespace ? `${namespace}:${key}` : key;
+        const options = params ? { ...params } : {};
+        const translation = i18next.t(id, options);
+        return translation || key;
+    }
+    plural(count, ...args) {
+        const [key, namespace, params] = this.extractParams(...args);
+        if (!this.initialized) {
+            console.warn("i18n not initialized yet");
+            return key;
+        }
+        const id = namespace ? `${namespace}:${key}` : key;
+        const options = { count, ...params };
+        const translation = i18next.t(id, options);
+        return translation || key;
+    }
+    exists(key, locale, namespace) {
+        if (!this.initialized) {
+            return false;
+        }
+        const id = namespace ? `${namespace}:${key}` : key;
+        const targetLocale = locale || this.currentLocale;
+        return i18next.exists(id, { lng: targetLocale });
+    }
+}
+const localeManager = new LocalizationManager();
+const t = localeManager.t.bind(localeManager);
+const plural = localeManager.plural.bind(localeManager);
+export function useLocale(namespace = "base") {
+    return {
+        t(key, params) {
+            return t(namespace, key, params);
+        },
+        plural(key, count, params) {
+            return plural(count, namespace, key, params);
+        },
+    };
+}
+export { localeManager, localeManager as i18n, t, plural };

package/dist/logging.d.ts

@@ -0,0 +1,172 @@
+import { EventDispatcher } from "./events";
+import { Plugin } from "./plugin";
+/**
+ * All possible log levels
+ *
+ * @public
+ */
+export interface ILogLevel {
+    1: "trace";
+    2: "debug";
+    3: "info";
+    4: "warn";
+    5: "error";
+}
+/**
+ * Logger class to handle consistency of logs across the plugin.
+ *
+ * @interface LogEntry
+ */
+export interface LogEntry {
+    traceId?: string;
+    level: string;
+    module: string;
+    location?: string;
+    message: string;
+    objects: any;
+}
+/**
+ * Logging options structure.
+ *
+ * @interface LogOptions
+ */
+export interface LogOptions {
+    minLevels: {
+        [module: string]: string;
+    };
+}
+/**
+ * Log level IDs (1 - 5)
+ *
+ * @public
+ */
+export type TLogLevelId = keyof ILogLevel;
+/**
+ * Log level names (trace - error)
+ *
+ * @public
+ */
+export type TLogLevelName = ILogLevel[TLogLevelId];
+type LogEvents = {
+    log: [logEntry: LogEntry];
+};
+/**
+ * Logger class to handle consistency of logs across the plugin.
+ *
+ * @class LogManager
+ * @extends {EventDispatcher}
+ */
+export declare class LogManager extends EventDispatcher<LogEvents> {
+    private options;
+    private consoleLoggerRegistered;
+    /**
+     * Set the minimum log levels for the module name or global.
+     *
+     * @param {LogOptions} options
+     * @returns {any} {LogManager}
+     */
+    configure(options: LogOptions): LogManager;
+    setLevel(module: string, level: TLogLevelName): void;
+    /**
+     * Returns a logger instance for the given module name.
+     *
+     * @param {string} module
+     * @returns {any} {Logger}
+     */
+    getLogger(module: string): Logger;
+    /**
+     *
+     *
+     * @param {(logEntry: LogEntry) => void} listener
+     * @returns {any} {LogManager}
+     */
+    onLogEntry(listener: (logEntry: LogEntry) => void): LogManager;
+    arrAvg: (arr: number[]) => number;
+    /**
+     * Registers a logger that write to the console.
+     *
+     * @returns {any} {LogManager}
+     */
+    registerConsoleLogger(props?: Partial<{
+        color: boolean;
+    }>): LogManager;
+}
+export declare const logging: LogManager;
+/**
+ * Main logging library, to view the logs a logger listener must be added. The
+ * Console Logger is already implemented for this project.
+ *
+ * @class Logger
+ */
+export declare class Logger {
+    readonly getLevel: () => string;
+    private logManager;
+    private module;
+    private readonly levels;
+    /**
+     * Creates an instance of Logger.
+     *
+     * @param {EventEmitter2} logManager
+     * @param {string} module
+     * @param {string} minLevel
+     */
+    constructor(logManager: EventDispatcher<LogEvents>, module: string, getLevel: () => string);
+    get minLevel(): number;
+    /**
+     * Converts a string level (trace/debug/info/warn/error) into a number
+     *
+     * @param minLevel
+     */
+    private levelToInt;
+    /**
+     * Central logging method.
+     *
+     * @param logLevel
+     * @param message
+     */
+    log(logLevel: string, message: string, objects?: any): void;
+    trace(message: string, objects?: any): void;
+    debug(message: string, objects?: any): void;
+    info(message: string, objects?: any): void;
+    warn(message: string, objects?: any): void;
+    error(message: string, objects?: any): void;
+    /**
+     * Central logging method with a trace ID to track calls between
+     * modules/components.
+     *
+     * @param logLevel
+     * @param message
+     */
+    logWithId(logLevel: string, traceId: string, message: string, objects?: any): void;
+    traceWithId(traceId: string, message: string, objects?: any): void;
+    debugWithId(traceId: string, message: string, objects?: any): void;
+    infoWithId(traceId: string, message: string, objects?: any): void;
+    warnWithId(traceId: string, message: string, objects?: any): void;
+    errorWithId(traceId: string, message: string, objects?: any): void;
+}
+/**
+ * This deceleration will log the time taken to run the function it is attached
+ * to. Be careful where it is added as it increases the output.
+ *
+ * @returns {any}
+ */
+export declare const logCall: (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function logCallDetails(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Provides a simple log function that can be used to log messages against
+ * default module.
+ *
+ * @param {TLogLevelName} logLevel
+ * @param {string} message
+ */
+export declare function log(logLevel: TLogLevelName, message: string): void;
+/**
+ * This allows the plugin to be debugged in a mobile application add it when
+ * debugging on a device. Not meant to be used by end users. Add it into main.ts
+ * and remove before you commit.
+ *
+ * @param {Plugin} plugin
+ * @returns {any}
+ */
+export declare function monkeyPatchConsole(plugin: Plugin): void;
+export {};