zotero-plugin 3.1.0 → 3.2.0

package/create-element.d.ts

@@ -0,0 +1,17 @@
+export declare const NAMESPACE: {
+    XUL: string;
+    HTML: string;
+};
+type Handler = (event?: any) => void | Promise<void>;
+export declare class Elements {
+    private prefix;
+    private document;
+    static all: WeakRef<Elements>[];
+    static removeAll(): void;
+    private className;
+    constructor(prefix: string, document: Document);
+    serialize(node: HTMLElement): string;
+    create(name: string, attrs?: Record<string, number | string | Handler | HTMLElement[]>): HTMLElement;
+    remove(): void;
+}
+export {};

package/create-element.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Elements = exports.NAMESPACE = void 0;
+exports.NAMESPACE = {
+    XUL: 'http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul',
+    HTML: 'http://www.w3.org/1999/xhtml',
+};
+class Elements {
+    static removeAll() {
+        for (const ref of this.all) {
+            try {
+                const elements = ref.deref();
+                if (elements)
+                    elements.document.querySelectorAll(`.${elements.className}`).forEach(e => e.remove());
+            }
+            catch (_a) { }
+        }
+        this.all = [];
+    }
+    constructor(prefix, document) {
+        this.prefix = prefix;
+        this.document = document;
+        this.className = `${prefix}-${Math.random()}-${Date.now()}`.replace('.', '-');
+        if (this.document.createXULElement)
+            Elements.all.push(new WeakRef(this));
+    }
+    serialize(node) {
+        const s = new XMLSerializer();
+        return s.serializeToString(node);
+    }
+    create(name, attrs = {}) {
+        const children = attrs.$ || [];
+        delete attrs.$;
+        const namespace = name.startsWith('html:') ? exports.NAMESPACE.HTML : exports.NAMESPACE.XUL;
+        name = name.replace('html:', '');
+        const elt = this.document.createXULElement
+            ? this.document[namespace === exports.NAMESPACE.XUL ? 'createXULElement' : 'createElement'](name)
+            : this.document.createElementNS(namespace, name);
+        attrs.class = `${this.className} ${attrs.class || ''}`.trim();
+        for (const [a, v] of Object.entries(attrs)) {
+            if (typeof v === 'string') {
+                elt.setAttribute(a, v);
+            }
+            else if (typeof v === 'number') {
+                elt.setAttribute(a, `${v}`);
+            }
+            else if (a.startsWith('on') && typeof v === 'function') {
+                elt.addEventListener(a.replace('on', ''), event => {
+                    var _a, _b;
+                    ;
+                    (_b = (_a = v(event)) === null || _a === void 0 ? void 0 : _a.catch) === null || _b === void 0 ? void 0 : _b.call(_a, err => {
+                        throw err;
+                    });
+                });
+            }
+            else {
+                throw new Error(`unexpected attribute ${a} of type ${typeof v}`);
+            }
+        }
+        for (const child of children) {
+            elt.appendChild(child);
+        }
+        return elt;
+    }
+    remove() {
+        for (const elt of Array.from(this.document.getElementsByClassName(this.className))) {
+            elt.remove();
+        }
+    }
+}
+exports.Elements = Elements;
+Elements.all = [];

package/logger.d.ts

@@ -0,0 +1,21 @@
+export declare const discard: {
+    log(): void;
+    error(): void;
+    warn(): void;
+    debug(): void;
+    info(): void;
+    clear(): void;
+    dir(): void;
+    table(): void;
+};
+export declare function format(...msg: any[]): string;
+export declare class Logger {
+    #private;
+    id: string;
+    phase: string;
+    constructor(id: string);
+    debug(...msg: any[]): void;
+    info(...msg: any[]): void;
+    error(...msg: any[]): void;
+    dump(msg: string, error?: Error): void;
+}

package/logger.js

@@ -0,0 +1,99 @@
+"use strict";
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-empty-function, no-restricted-syntax */
+var _Logger_instances, _Logger_prefix;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.discard = void 0;
+exports.format = format;
+const tslib_1 = require("tslib");
+exports.discard = {
+    log() { },
+    error() { },
+    warn() { },
+    debug() { },
+    info() { },
+    clear() { },
+    dir() { },
+    table() { },
+};
+function stringifyXPCOM(obj) {
+    if (!obj.QueryInterface)
+        return '';
+    if (obj.message)
+        return `[XPCOM error ${obj.message}]`;
+    if (obj.name)
+        return `[XPCOM object ${obj.name}]`;
+    return '[XPCOM object]';
+}
+function stringifyError(obj) {
+    if (obj instanceof Error)
+        return `[error: ${obj.message || '<unspecified error>'}\n${obj.stack}]`;
+    // guess it is an errorevent
+    if (obj.error instanceof Error && obj.message)
+        return `[errorevent: ${obj.message} ${stringifyError(obj.error)}]`;
+    if (typeof ErrorEvent !== 'undefined' && obj instanceof ErrorEvent)
+        return `[errorevent: ${obj.message || '<unspecified errorevent>'}]`;
+    return '';
+}
+function replacer() {
+    const seen = new WeakSet();
+    return (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value))
+                return '[Circular]';
+            seen.add(value);
+        }
+        if (value === null)
+            return value;
+        if (value instanceof Set)
+            return [...value];
+        if (value instanceof Map)
+            return Object.fromEntries(value);
+        switch (typeof value) {
+            case 'string':
+            case 'number':
+            case 'boolean':
+                return value;
+            case 'object':
+                return stringifyXPCOM(value) || stringifyError(value) || value;
+        }
+        if (Array.isArray(value))
+            return value;
+        return undefined;
+    };
+}
+function to_s(obj) {
+    if (typeof obj === 'string')
+        return obj;
+    return JSON.stringify(obj, replacer(), 2);
+}
+function format(...msg) {
+    return msg.map(to_s).join(' ');
+}
+class Logger {
+    constructor(id) {
+        _Logger_instances.add(this);
+        this.id = id;
+        this.phase = '';
+    }
+    debug(...msg) {
+        Zotero.debug(`${tslib_1.__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_prefix).call(this)}${format(...msg)}\n`);
+    }
+    info(...msg) {
+        Zotero.debug(`${tslib_1.__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_prefix).call(this)}${format(...msg)}\n`);
+    }
+    error(...msg) {
+        Zotero.debug(`${tslib_1.__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_prefix).call(this, true)}${format(...msg)}\n`);
+    }
+    dump(msg, error) {
+        if (error) {
+            dump(`${tslib_1.__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_prefix).call(this, error)}${format(msg, error)}\n`);
+        }
+        else {
+            dump(`${tslib_1.__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_prefix).call(this)}${format(msg)}\n`);
+        }
+    }
+}
+exports.Logger = Logger;
+_Logger_instances = new WeakSet(), _Logger_prefix = function _Logger_prefix(error) {
+    return `{${error ? 'error: ' : ''}${this.phase}${this.id}} `;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zotero-plugin",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Zotero plugin builder",
   "homepage": "https://github.com/retorquere/zotero-plugin/wiki",
   "bin": {
@@ -100,7 +100,11 @@
     "version.d.ts",
     "version.js",
     "debug-log.js",
-    "debug-log.d.ts"
+    "debug-log.d.ts",
+    "create-element.js",
+    "create-element.d.ts",
+    "logger.js",
+    "logger.d.ts"
   ],
   "bugs": {
     "url": "https://github.com/retorquere/zotero-plugin/issues"