refkit-js 0.0.0 → 0.2.1

package/dist/raw.js

@@ -0,0 +1,191 @@
+import { NativeRawDocument } from "./wasm/refkit_js_native.js";
+import { assertInitialized } from "./runtime.js";
+import { callNative, readNative } from "./errors.js";
+import { string } from "./inputs.js";
+import { tidyBibtex } from "./tidy.js";
+let entryMap;
+let entry;
+let fieldMap;
+let field;
+const sourceDiagnostics = new WeakMap();
+export function setBibDecodingDiagnostic(document, diagnostic) {
+    sourceDiagnostics.set(document, diagnostic ? [diagnostic] : []);
+}
+export class BibDocument {
+    #native;
+    constructor(native) {
+        this.#native = native;
+    }
+    static parse(source) {
+        assertInitialized();
+        return new BibDocument(callNative(() => NativeRawDocument.parse(string(source, "source"))));
+    }
+    #metadata() {
+        return readNative(() => this.#native.metadata());
+    }
+    get entries() {
+        return entryMap(this.#native);
+    }
+    get diagnostics() {
+        return [
+            ...structuredClone(sourceDiagnostics.get(this) ?? []),
+            ...this.#metadata().diagnostics,
+        ];
+    }
+    get comments() {
+        return this.#metadata().comments;
+    }
+    get preamble() {
+        return this.#metadata().preamble;
+    }
+    get strings() {
+        return this.#metadata().strings;
+    }
+    get failedBlocks() {
+        return this.#metadata().failedBlocks;
+    }
+    get blocks() {
+        return this.#metadata().blocks;
+    }
+    toBibtex() {
+        return callNative(() => this.#native.to_bibtex());
+    }
+    tidy(settings = {}) {
+        return tidyBibtex(this.toBibtex(), settings);
+    }
+}
+export class BibEntryMap {
+    #native;
+    constructor(native) {
+        this.#native = native;
+    }
+    static {
+        entryMap = (native) => new BibEntryMap(native);
+    }
+    #records() {
+        return readNative(() => this.#native.entries());
+    }
+    uniqueKeys() {
+        return readNative(() => this.#native.entry_keys());
+    }
+    occurrenceKeys() {
+        return this.#records().map((info) => info.key);
+    }
+    occurrences() {
+        return this.#records().map((info) => entry(this.#native, info));
+    }
+    getAll(key) {
+        const records = readNative(() => this.#native.entries_for_key(string(key, "key")));
+        return records.map((info) => entry(this.#native, info));
+    }
+    getUnique(key) {
+        const info = readNative(() => this.#native.unique_entry(string(key, "key")));
+        return info === null ? null : entry(this.#native, info);
+    }
+    get size() {
+        return callNative(() => this.#native.entry_count());
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    has(key) {
+        return this.getAll(key).length > 0;
+    }
+    [Symbol.iterator]() {
+        return this.occurrences()[Symbol.iterator]();
+    }
+}
+export class BibEntry {
+    #native;
+    #info;
+    constructor(native, info) {
+        this.#native = native;
+        this.#info = info;
+    }
+    static {
+        entry = (native, info) => new BibEntry(native, info);
+    }
+    get key() {
+        return this.#info.key;
+    }
+    get kind() {
+        return this.#info.kind;
+    }
+    get span() {
+        return [...this.#info.span];
+    }
+    get fields() {
+        return fieldMap(this.#native, this.#info.id);
+    }
+}
+export class BibFieldMap {
+    #native;
+    #entryId;
+    constructor(native, entryId) {
+        this.#native = native;
+        this.#entryId = entryId;
+    }
+    static {
+        fieldMap = (native, entryId) => new BibFieldMap(native, entryId);
+    }
+    #records() {
+        return readNative(() => this.#native.fields(this.#entryId));
+    }
+    uniqueKeys() {
+        return readNative(() => this.#native.field_keys(this.#entryId));
+    }
+    occurrenceKeys() {
+        return this.#records().map((info) => info.name);
+    }
+    occurrences() {
+        return this.#records().map((info) => field(this.#native, this.#entryId, info));
+    }
+    getAll(key) {
+        const records = readNative(() => this.#native.fields_for_key(this.#entryId, string(key, "key")));
+        return records.map((info) => field(this.#native, this.#entryId, info));
+    }
+    getUnique(key) {
+        const info = readNative(() => this.#native.unique_field(this.#entryId, string(key, "key")));
+        return info === null ? null : field(this.#native, this.#entryId, info);
+    }
+    get size() {
+        return callNative(() => this.#native.field_count(this.#entryId));
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    has(key) {
+        return this.getAll(key).length > 0;
+    }
+    [Symbol.iterator]() {
+        return this.occurrences()[Symbol.iterator]();
+    }
+}
+export class BibField {
+    #native;
+    #entryId;
+    #id;
+    constructor(native, entryId, info) {
+        this.#native = native;
+        this.#entryId = entryId;
+        this.#id = info.id;
+    }
+    static {
+        field = (native, entryId, info) => new BibField(native, entryId, info);
+    }
+    #info() {
+        return readNative(() => this.#native.field(this.#entryId, this.#id));
+    }
+    get name() {
+        return this.#info().name;
+    }
+    get span() {
+        return this.#info().span;
+    }
+    get value() {
+        return this.#info().value;
+    }
+    set value(value) {
+        callNative(() => this.#native.set_field_value(this.#entryId, this.#id, string(value, "value")));
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,14 @@
+import { type InitInput, type SyncInitInput } from "./wasm/refkit_js_native.js";
+export type InitOptions = InitInput | Promise<InitInput> | {
+    module_or_path: InitInput | Promise<InitInput>;
+};
+/** Initialize the shared WebAssembly module before calling the browser API. */
+export declare function init(input?: InitOptions): Promise<void>;
+export declare function initializeSync(module: SyncInitInput): void;
+export declare function assertInitialized(): void;
+export interface BuildInfo {
+    readonly version: string;
+    readonly buildMode: "debug" | "release";
+    readonly target: string;
+}
+export declare function getBuildInfo(): BuildInfo;

package/dist/runtime.js

@@ -0,0 +1,58 @@
+import initialize, { build_info, initSync, } from "./wasm/refkit_js_native.js";
+import { RefkitError, readNative } from "./errors.js";
+import { version } from "./wasm/version.js";
+const supportsFinalization = typeof FinalizationRegistry === "function";
+let ready = false;
+let pending;
+/** Initialize the shared WebAssembly module before calling the browser API. */
+export function init(input) {
+    assertRuntimeSupport();
+    if (ready)
+        return Promise.resolve();
+    if (!pending) {
+        const moduleOrPath = input && typeof input === "object" && "module_or_path" in input
+            ? input.module_or_path
+            : (input ??
+                new URL("./wasm/refkit_js_native_bg.wasm", import.meta.url));
+        pending = initialize({ module_or_path: moduleOrPath })
+            .then(() => {
+            verifyVersion();
+            ready = true;
+        })
+            .catch((error) => {
+            pending = undefined;
+            throw error;
+        });
+    }
+    return pending;
+}
+export function initializeSync(module) {
+    assertRuntimeSupport();
+    if (ready)
+        return;
+    if (pending) {
+        throw new RefkitError("Await the pending browser initialization before importing refkit-js/node.");
+    }
+    initSync({ module });
+    verifyVersion();
+    ready = true;
+}
+export function assertInitialized() {
+    if (!ready)
+        throw new RefkitError("RefKit is not initialized. Await init() before calling the browser API.");
+}
+function verifyVersion() {
+    const info = readNative(() => build_info());
+    if (info.version !== version) {
+        throw new RefkitError(`WebAssembly version ${info.version} is incompatible with refkit-js ${version}. Install JavaScript and WebAssembly from the same release.`);
+    }
+}
+export function getBuildInfo() {
+    assertInitialized();
+    return readNative(() => build_info());
+}
+function assertRuntimeSupport() {
+    if (!supportsFinalization) {
+        throw new RefkitError("RefKit requires FinalizationRegistry. Use Node.js 22.19 or newer, or update your browser.");
+    }
+}

package/dist/tidy.d.ts

@@ -0,0 +1,5 @@
+import type { TidyOptions, TidyResult } from "./types.js";
+export interface TidySettings {
+    options?: TidyOptions | null;
+}
+export declare function tidyBibtex(source: string, settings?: TidySettings): TidyResult;

package/dist/tidy.js

@@ -0,0 +1,31 @@
+import { tidy_bibtex } from "./wasm/refkit_js_native.js";
+import { assertInitialized } from "./runtime.js";
+import { readNative } from "./errors.js";
+import { object, string } from "./inputs.js";
+export function tidyBibtex(source, settings = {}) {
+    assertInitialized();
+    string(source, "source");
+    object(settings, "settings", ["options"]);
+    const options = settings.options ?? {};
+    object(options, "options");
+    const input = JSON.stringify(options, function (key, value) {
+        if (value === undefined && Array.isArray(this)) {
+            throw new TypeError("tidy option arrays must contain defined values");
+        }
+        const original = key === "" ? options : this[key];
+        if (original !== null &&
+            typeof original === "object" &&
+            !Array.isArray(original)) {
+            object(original, "tidy option");
+            if (value !== original)
+                throw new TypeError("tidy options must contain plain values");
+        }
+        if (typeof value === "number" && !Number.isFinite(value))
+            throw new TypeError("tidy options require finite numbers");
+        if (["function", "symbol", "bigint"].includes(typeof value)) {
+            throw new TypeError("tidy options must contain JSON values");
+        }
+        return value;
+    });
+    return readNative(() => tidy_bibtex(source, input));
+}

package/dist/types.d.ts

@@ -0,0 +1,182 @@
+export type RecoveryPolicy = "error" | "report";
+export type RawSpan = readonly [number, number];
+export interface Diagnostic {
+    readonly code: string;
+    readonly severity: "error" | "warning";
+    readonly action: "rejected" | "dropped_block" | "dropped_field" | "literalized" | "decoded";
+    readonly span: RawSpan | null;
+    readonly entry: string | null;
+    readonly field: string | null;
+    readonly message: string;
+}
+export interface Entry {
+    readonly key: string;
+    readonly entryType: string;
+    readonly title: string | null;
+    readonly date: string | null;
+    readonly doi: string | null;
+    readonly volume: string | null;
+    readonly parents: readonly Entry[];
+}
+export type ProjectionField = "key" | "entryType" | "type" | "title" | "date" | "doi" | "volume";
+export interface ProjectionRow {
+    key?: string;
+    entryType?: string;
+    type?: string;
+    title?: string | null;
+    date?: string | null;
+    doi?: string | null;
+    volume?: string | null;
+}
+export interface BibliographyLayout {
+    readonly hangingIndent: boolean;
+    readonly secondFieldAlign: "Margin" | "Flush" | null;
+    readonly lineSpacing: number;
+    readonly entrySpacing: number;
+}
+export type RenderedMeta = {
+    readonly kind: "Entry";
+    readonly key: string;
+    readonly itemIndex: number;
+} | {
+    readonly kind: "Names";
+    readonly roles: readonly string[];
+} | {
+    readonly kind: "Name";
+    readonly role: string;
+    readonly index: number;
+} | {
+    readonly kind: "Date" | "Text" | "Number" | "Label" | "CitationNumber" | "CitationLabel";
+};
+export interface RenderedFormatting {
+    readonly fontStyle: "Normal" | "Italic";
+    readonly fontVariant: "Normal" | "SmallCaps";
+    readonly fontWeight: "Normal" | "Bold" | "Light";
+    readonly textDecoration: "None" | "Underline";
+    readonly verticalAlign: "None" | "Baseline" | "Sup" | "Sub";
+}
+export interface RenderedText {
+    readonly kind: "Text";
+    readonly text: string;
+    readonly formatting: RenderedFormatting;
+}
+export interface RenderedElement {
+    readonly kind: "Element";
+    readonly display: "Block" | "LeftMargin" | "RightInline" | "Indent" | null;
+    readonly meta: RenderedMeta | null;
+    readonly children: readonly RenderedNode[];
+}
+export interface RenderedMarkup {
+    readonly kind: "Markup";
+    readonly value: string;
+}
+export interface RenderedLink {
+    readonly kind: "Link";
+    readonly text: string;
+    readonly url: string;
+    readonly formatting: RenderedFormatting;
+}
+export interface RenderedTransparent {
+    readonly kind: "Transparent";
+    readonly citeIdx: number;
+    readonly formatting: RenderedFormatting;
+}
+export type RenderedNode = RenderedText | RenderedElement | RenderedMarkup | RenderedLink | RenderedTransparent;
+export interface BibliographyEntry {
+    readonly kind: "bibliography-entry";
+    readonly key: string;
+    readonly label: RenderedNode | null;
+    readonly content: readonly RenderedNode[];
+}
+export type RenderedTree = readonly (RenderedNode | BibliographyEntry)[];
+export interface Rendered {
+    readonly text: string;
+    readonly html: string;
+    readonly layout: BibliographyLayout | null;
+    readonly tree: RenderedTree;
+}
+export interface RawWhitespaceBlock {
+    readonly kind: "whitespace";
+    readonly span: RawSpan;
+}
+export interface RawCommentBlock {
+    readonly kind: "comment";
+    readonly raw: string;
+    readonly span: RawSpan;
+}
+export interface RawPreambleBlock {
+    readonly kind: "preamble";
+    readonly value: string;
+    readonly span: RawSpan;
+}
+export interface RawStringBlock {
+    readonly kind: "string";
+    readonly key: string;
+    readonly value: string;
+    readonly span: RawSpan;
+}
+export interface RawEntryBlock {
+    readonly kind: "entry";
+    readonly id: number;
+    readonly key: string;
+    readonly span: RawSpan;
+}
+export interface RawFailedBlock {
+    readonly kind: "failed";
+    readonly raw: string;
+    readonly error: string;
+    readonly span: RawSpan;
+}
+export interface RawOtherBlock {
+    readonly kind: "other";
+    readonly raw: string;
+    readonly span: RawSpan;
+}
+export type RawBlock = RawWhitespaceBlock | RawCommentBlock | RawPreambleBlock | RawStringBlock | RawEntryBlock | RawFailedBlock | RawOtherBlock;
+export type DuplicateRule = "doi" | "key" | "abstract" | "citation";
+export type MergeStrategy = "first" | "last" | "combine" | "overwrite";
+export interface TidyOptions {
+    omit?: readonly string[] | null;
+    curly?: boolean;
+    numeric?: boolean;
+    months?: boolean;
+    space?: number;
+    tab?: boolean;
+    align?: boolean | number | null;
+    blankLines?: boolean;
+    sort?: boolean | readonly string[] | null;
+    duplicates?: readonly DuplicateRule[] | null;
+    merge?: MergeStrategy | null;
+    stripEnclosingBraces?: boolean;
+    dropAllCaps?: boolean;
+    escape?: boolean;
+    sortFields?: boolean | readonly string[] | null;
+    stripComments?: boolean;
+    trailingCommas?: boolean;
+    encodeUrls?: boolean;
+    tidyComments?: boolean;
+    removeEmptyFields?: boolean;
+    removeDuplicateFields?: boolean;
+    generateKeys?: boolean | string | null;
+    maxAuthors?: number | null;
+    lowercase?: boolean;
+    enclosingBraces?: boolean | readonly string[] | null;
+    removeBraces?: boolean | readonly string[] | null;
+    wrap?: boolean | number | null;
+}
+export interface TidyWarning {
+    readonly code: "missing_key" | "duplicate_entry";
+    readonly rule: DuplicateRule | null;
+    readonly message: string;
+}
+export interface TidyRename {
+    readonly entryId: number;
+    readonly oldKey: string;
+    readonly newKey: string;
+}
+export interface TidyResult {
+    readonly bibtex: string;
+    readonly warnings: readonly TidyWarning[];
+    readonly renames: readonly TidyRename[];
+    readonly count: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wasm/refkit_js_native.d.ts

@@ -0,0 +1,142 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class NativeDocument {
+    free(): void;
+    [Symbol.dispose](): void;
+    cited_bibliography(citations: string): string;
+    full_bibliography(): string;
+    constructor(library: NativeLibrary, style: NativeStyle, locale?: string | null);
+    render(citations: string): string;
+}
+
+export class NativeLibrary {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    diagnostics(): string;
+    get_many(keys: string): string;
+    get_record(key: string): string;
+    keys(): string;
+    static parse_bibtex(source: string, recovery: string): NativeLibrary;
+    static parse_yaml(source: string): NativeLibrary;
+    project(fields?: string | null, keys?: string | null): string;
+    records(): string;
+    select_records(selector: string): string;
+    readonly size: number;
+}
+
+export class NativeRawDocument {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    entries(): string;
+    entries_for_key(key: string): string;
+    entry_count(): number;
+    entry_keys(): string;
+    field(entry_id: number, field_id: number): string;
+    field_count(entry_id: number): number;
+    field_keys(entry_id: number): string;
+    fields(entry_id: number): string;
+    fields_for_key(entry_id: number, key: string): string;
+    metadata(): string;
+    static parse(source: string): NativeRawDocument;
+    set_field_value(entry_id: number, field_id: number, value: string): void;
+    to_bibtex(): string;
+    unique_entry(key: string): string;
+    unique_field(entry_id: number, key: string): string;
+}
+
+export class NativeStyle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_xml(xml: string): NativeStyle;
+    static load(name: string): NativeStyle;
+    readonly id: string;
+    readonly title: string;
+}
+
+export function build_info(): string;
+
+export function decode_bibliography(bytes: Uint8Array): string;
+
+export function is_bundled_locale(code: string): boolean;
+
+export function tidy_bibtex(source: string, options: string): string;
+
+export function validate_tidy_options(options: string): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_nativedocument_free: (a: number, b: number) => void;
+    readonly __wbg_nativelibrary_free: (a: number, b: number) => void;
+    readonly __wbg_nativerawdocument_free: (a: number, b: number) => void;
+    readonly __wbg_nativestyle_free: (a: number, b: number) => void;
+    readonly build_info: (a: number) => void;
+    readonly decode_bibliography: (a: number, b: number, c: number) => void;
+    readonly is_bundled_locale: (a: number, b: number) => number;
+    readonly nativedocument_cited_bibliography: (a: number, b: number, c: number, d: number) => void;
+    readonly nativedocument_full_bibliography: (a: number, b: number) => void;
+    readonly nativedocument_new: (a: number, b: number, c: number, d: number) => number;
+    readonly nativedocument_render: (a: number, b: number, c: number, d: number) => void;
+    readonly nativelibrary_diagnostics: (a: number, b: number) => void;
+    readonly nativelibrary_get_many: (a: number, b: number, c: number, d: number) => void;
+    readonly nativelibrary_get_record: (a: number, b: number, c: number, d: number) => void;
+    readonly nativelibrary_keys: (a: number, b: number) => void;
+    readonly nativelibrary_parse_bibtex: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly nativelibrary_parse_yaml: (a: number, b: number, c: number) => void;
+    readonly nativelibrary_project: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly nativelibrary_records: (a: number, b: number) => void;
+    readonly nativelibrary_select_records: (a: number, b: number, c: number, d: number) => void;
+    readonly nativelibrary_size: (a: number) => number;
+    readonly nativerawdocument_entries: (a: number, b: number) => void;
+    readonly nativerawdocument_entries_for_key: (a: number, b: number, c: number, d: number) => void;
+    readonly nativerawdocument_entry_count: (a: number) => number;
+    readonly nativerawdocument_entry_keys: (a: number, b: number) => void;
+    readonly nativerawdocument_field: (a: number, b: number, c: number, d: number) => void;
+    readonly nativerawdocument_field_count: (a: number, b: number, c: number) => void;
+    readonly nativerawdocument_field_keys: (a: number, b: number, c: number) => void;
+    readonly nativerawdocument_fields: (a: number, b: number, c: number) => void;
+    readonly nativerawdocument_fields_for_key: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly nativerawdocument_metadata: (a: number, b: number) => void;
+    readonly nativerawdocument_parse: (a: number, b: number) => number;
+    readonly nativerawdocument_set_field_value: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly nativerawdocument_to_bibtex: (a: number, b: number) => void;
+    readonly nativerawdocument_unique_entry: (a: number, b: number, c: number, d: number) => void;
+    readonly nativerawdocument_unique_field: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly nativestyle_from_xml: (a: number, b: number, c: number) => void;
+    readonly nativestyle_id: (a: number, b: number) => void;
+    readonly nativestyle_load: (a: number, b: number, c: number) => void;
+    readonly nativestyle_title: (a: number, b: number) => void;
+    readonly tidy_bibtex: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly validate_tidy_options: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export2: (a: number, b: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;