@lakutata/dbus 2.3.1 → 3.0.0-beta.0

package/dist/esm/components/DBusObjectManager.js

@@ -0,0 +1,197 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component } from '@lakutata/core';
+import { Autoload, Singleton } from '@lakutata/core/decorator/di';
+import { checkPathTemplate } from '../lib/Names.js';
+export const ATTACH = Symbol('DBUS.OBJECT.MANAGER.ATTACH');
+export const STORE = Symbol('DBUS.OBJECT.MANAGER.STORE');
+/**
+ * The application's D-Bus objects: it adds and removes the objects of the path templates of `@DBusInterface`
+ * (`/com/example/Devices/{sn}`), keeps the values of their properties, and emits their signals. Inject it
+ * (`@Inject(DBusObjectManager)`) or get it (`getObject(DBusObjectManager)`) from any object: it is autoloaded, a
+ * singleton of the application, and needs no registration.
+ *
+ * Its state lives in the application, not on the bus: the objects added before a {@link dbusEntrypoint} starts are
+ * exported when it starts, and every running D-Bus adapter whose interfaces match a path exports the object. The
+ * clients are told of the objects added and removed by the `org.freedesktop.DBus.ObjectManager` interface of the root
+ * object (`InterfacesAdded`, `InterfacesRemoved`).
+ *
+ * It emits `propertyWritten` (a {@link DBusPropertyWrite}) when a client writes a writable property.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {DBusObjectManager, defineDBusProperty, defineDBusSignal, type DBusPropertyWrite} from '@lakutata/dbus'
+ *
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ * export const DeviceLevel = defineDBusProperty<number>('Level', 'i', {writable: true, initial: 1})
+ * export const DeviceRemoved = defineDBusSignal<string>('Removed', 's')
+ *
+ * //Declared in the components of the application, with the controllers of the interfaces at /com/example/Devices/{sn}
+ * export class Devices extends Component {
+ *     @Inject(DBusObjectManager)
+ *     protected readonly manager: DBusObjectManager
+ *
+ *     protected async init(): Promise<void> {
+ *         this.manager.on('propertyWritten', (write: DBusPropertyWrite): void => {
+ *             if (write.property === DeviceLevel) console.log(`${write.path}: level ${write.value}`)
+ *         })
+ *     }
+ *
+ *     public plug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.addObject(path)
+ *         this.manager.setPropertyValue(path, DeviceState, 'running')
+ *     }
+ *
+ *     public unplug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.emitSignal(path, DeviceRemoved, sn)
+ *         this.manager.removeObject(path)
+ *     }
+ * }
+ * ```
+ */
+let DBusObjectManager = class DBusObjectManager extends Component {
+    #objects = new Set();
+    #values = new Map();
+    #sinks = new Set();
+    /**
+     * Send the changes to an adapter until the returned function is called; the objects already added are exported by it
+     * @param sink
+     */
+    [ATTACH](sink) {
+        this.#sinks.add(sink);
+        this.#objects.forEach((path) => sink.addObject(path));
+        return () => void this.#sinks.delete(sink);
+    }
+    /**
+     * Keep a value written by a client
+     * @param write
+     */
+    [STORE](write) {
+        this.#valuesOf(write.path).set(write.property, write.value);
+        this.emit('propertyWritten', write);
+    }
+    /**
+     * The values of the properties of an object
+     * @param path
+     */
+    #valuesOf(path) {
+        let values = this.#values.get(path);
+        if (!values) {
+            values = new Map();
+            this.#values.set(path, values);
+        }
+        return values;
+    }
+    /**
+     * Add an object: every running D-Bus adapter whose interfaces have a path template matching it (or the same path)
+     * exports it, with those interfaces, and the adapters started later export it when they start. The variables of the
+     * matching templates are given to the methods called on it. An object whose path matches no template is kept, but
+     * not exported.
+     * @param path The object path (`'/com/example/Devices/A1'`), not a template.
+     * @returns `false` when the object was already added, `true` otherwise.
+     * @throws {TypeError} When the path is invalid, or is a template (it contains braces).
+     */
+    addObject(path) {
+        checkPathTemplate(path);
+        if (/[{}]/.test(path))
+            throw new TypeError(`The object path "${path}" is a template, not the path of an object`);
+        if (this.#objects.has(path))
+            return false;
+        this.#objects.add(path);
+        this.#sinks.forEach((sink) => sink.addObject(path));
+        return true;
+    }
+    /**
+     * Remove an object added with {@link addObject}: the adapters stop exporting it, and its property values are
+     * forgotten (added again, it starts from the initial values). A fixed object (the path of a template without
+     * variables, exported by the adapters themselves) stays exported, with its property values, when it was also
+     * added: only its entry in {@link objects} is removed.
+     * @param path The object path given to {@link addObject}.
+     * @returns `false` when the object was not added, `true` otherwise.
+     */
+    removeObject(path) {
+        if (!this.#objects.delete(path))
+            return false;
+        let fixed = false;
+        this.#sinks.forEach((sink) => {
+            //An adapter keeps the objects it exports by itself
+            if (sink.isFixed(path))
+                fixed = true;
+            else
+                sink.removeObject(path);
+        });
+        if (!fixed)
+            this.#values.delete(path);
+        return true;
+    }
+    /**
+     * Tell whether an object was added with {@link addObject} and not removed since.
+     * @param path The object path.
+     * @returns `true` when the object is added.
+     */
+    hasObject(path) {
+        return this.#objects.has(path);
+    }
+    /**
+     * List the objects added with {@link addObject}, in the order they were added; the objects of the paths without
+     * variables, exported by the adapters themselves, are not listed.
+     * @returns The object paths.
+     */
+    objects() {
+        return [...this.#objects];
+    }
+    /**
+     * Set the value of a property on an object, validated by the property's schema: the clients read it from then on,
+     * and the running adapters exporting the object announce it (`PropertiesChanged`). The value is kept even when no
+     * adapter exports the object yet.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param property The property's definition, listed in the `properties` of the object's interface.
+     * @param value The new value.
+     * @throws {InvalidValueException} When the value does not match the property's schema; nothing is changed.
+     */
+    setPropertyValue(path, property, value) {
+        const validated = property.validate(value);
+        this.#valuesOf(path).set(property, validated);
+        this.#sinks.forEach((sink) => sink.propertyChanged(path, property, validated));
+    }
+    /**
+     * Get the value of a property on an object: the last value set by the application or written by a client.
+     * @param path The object path.
+     * @param property The property's definition.
+     * @returns The value, or the property's `initial` value until one is set.
+     */
+    getPropertyValue(path, property) {
+        const values = this.#values.get(path);
+        return values?.has(property) ? values.get(property) : property.initial;
+    }
+    /**
+     * Emit a signal from an object, through every running adapter exporting the object with an interface listing the
+     * signal. The data is validated by the signal's DTO first.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param signal The signal's definition, listed in the `signals` of the object's interface.
+     * @param data The data of the signal.
+     * @returns `false` when no running adapter exports the object with this signal (nothing is sent), `true` otherwise.
+     * @throws {InvalidValueException} When the data does not match the signal's DTO.
+     */
+    emitSignal(path, signal, data) {
+        const validated = signal.validate(data);
+        let emitted = false;
+        this.#sinks.forEach((sink) => {
+            if (sink.emitSignal(path, signal, validated))
+                emitted = true;
+        });
+        return emitted;
+    }
+};
+DBusObjectManager = __decorate([
+    Autoload(),
+    Singleton()
+], DBusObjectManager);
+export { DBusObjectManager };

package/dist/esm/context/DBusContext.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { BaseContext } from '@lakutata/entrypoint';
+/**
+ * The `type` of every {@link DBusContext}: `'DBUS'`. A middleware or an access rule shared by several transports tells
+ * the D-Bus calls apart with it.
+ */
+export const DBUS_CONTEXT_TYPE = 'DBUS';
+/**
+ * The context of a D-Bus method call: `this.context` of a controller action declared with `@DBusMethod` when a client
+ * calls it through {@link dbusEntrypoint}. The adapter creates one per call; its `data` is the call's input (the entries
+ * of its `a{sv}` dictionary). The variables of the object path template are not in the context: they are merged into
+ * the action's input, as the route parameters of HTTP.
+ * @example
+ * ```typescript
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {DBusContext, DBusInterface, DBusMethod} from '@lakutata/dbus'
+ *
+ * @DBusInterface('com.example.Manager', {path: '/com/example/Manager'})
+ * class ManagerController extends Controller {
+ *     //Returns "com.example.Manager.Ping at /com/example/Manager"
+ *     @DBusMethod('Ping', {returns: 's'})
+ *     public async ping(): Promise<string> {
+ *         const context: DBusContext = this.context as DBusContext
+ *         return `${context.interface}.${context.member} at ${context.path}`
+ *     }
+ * }
+ * ```
+ */
+export class DBusContext extends BaseContext {
+    /**
+     * Create the context of a method call, validating its properties.
+     * @param params The object path, the interface, the method and the input of the call.
+     * @throws {InvalidValueException} When a property is missing or invalid.
+     */
+    constructor(params) {
+        super(params);
+    }
+}
+__decorate([
+    Expect(DTO.String().valid(DBUS_CONTEXT_TYPE).default(DBUS_CONTEXT_TYPE)),
+    __metadata("design:type", String)
+], DBusContext.prototype, "type", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "path", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "interface", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "member", void 0);

package/dist/esm/decorators/DBusInterface.js

@@ -0,0 +1,60 @@
+import { setPrefix } from '@lakutata/entrypoint/channel';
+import { setDBusInterfaceDeclaration } from '../lib/Declarations.js';
+/**
+ * Serve a controller as a D-Bus interface: its `@DBusMethod` actions are the interface's methods, and the signals and
+ * properties of the options are its other members, on the objects at `options.path`. The controllers declaring the same
+ * path are served by the same objects, each one interface; a subclass inherits the declaration of its parent class.
+ * The objects also implement `org.freedesktop.DBus.Properties`, `Introspectable` and `Peer`, and the root object `/`
+ * implements `ObjectManager`. Nothing is served until a {@link dbusEntrypoint} runs.
+ * @param name The name of the interface (`'com.example.Device'`): two or more elements separated by dots, made of
+ * letters, digits and `_`, not starting with a digit; 255 characters at most.
+ * @param options The object path (or template) of the interface, its signals and its properties.
+ * @returns The class decorator.
+ * @throws {TypeError} When the class is declared, if the name of the interface or the path is invalid.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {Expect, Return} from 'lakutata/decorator/dto'
+ * import {DBusInterface, DBusMethod, defineDBusProperty, defineDBusSignal} from '@lakutata/dbus'
+ *
+ * class DeviceSnDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ * }
+ *
+ * class StatusDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ *
+ *     @Expect(DTO.Boolean().required())
+ *     public online: boolean
+ * }
+ *
+ * export const DeviceChanged = defineDBusSignal('Changed', StatusDTO)
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ *
+ * //Served by the objects /com/example/Devices/A1, /com/example/Devices/B2… added with DBusObjectManager
+ * @DBusInterface('com.example.Device', {path: '/com/example/Devices/{sn}', signals: [DeviceChanged], properties: [DeviceState]})
+ * export class DeviceController extends Controller {
+ *     //The sn of the input is the one of the object path
+ *     @DBusMethod('Status', DeviceSnDTO)
+ *     @Return(StatusDTO)
+ *     public async status(input: DeviceSnDTO): Promise<StatusDTO> {
+ *         return {sn: input.sn, online: true} as StatusDTO
+ *     }
+ * }
+ * ```
+ */
+export function DBusInterface(name, options) {
+    return (target) => {
+        setDBusInterfaceDeclaration(target, {
+            interface: name,
+            path: options.path,
+            signals: options.signals ?? [],
+            properties: options.properties ?? []
+        });
+        //The methods of the controller are addressed at its interface and its path
+        setPrefix(target, { dbus: { path: options.path, interface: name } });
+    };
+}

package/dist/esm/decorators/DBusMethod.js

@@ -0,0 +1,17 @@
+import { getActionDTOAndOptions, registerControllerAction } from '@lakutata/entrypoint/channel';
+import { DBusChannel } from '../channel/DBusChannel.js';
+import { schemaSignature } from '../lib/Signature.js';
+export function DBusMethod(name, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const isDTO = typeof dtoConstructorOrOptions === 'function';
+        const { returns, ...actionOptions } = (isDTO ? options : dtoConstructorOrOptions) ?? {};
+        const [dtoConstructor, validatedOptions] = isDTO
+            ? getActionDTOAndOptions(dtoConstructorOrOptions, actionOptions)
+            : getActionDTOAndOptions(actionOptions);
+        const pattern = { member: name };
+        if (returns !== undefined)
+            pattern.returns = typeof returns === 'string' ? returns : schemaSignature(returns);
+        registerControllerAction(DBusChannel, target, propertyKey, pattern, dtoConstructor, validatedOptions);
+        return descriptor;
+    };
+}

package/dist/esm/exports/DBus.js

@@ -0,0 +1,12 @@
+//The DBus channel: the controllers served as the interfaces of the DBus objects
+export { DBusChannel } from '../channel/DBusChannel.js';
+export { DBusContext, DBUS_CONTEXT_TYPE } from '../context/DBusContext.js';
+export { DBusInterface } from '../decorators/DBusInterface.js';
+export { DBusMethod } from '../decorators/DBusMethod.js';
+export { defineDBusSignal, defineDBusProperty } from '../lib/Declarations.js';
+export { dbusEntrypoint } from '../adapters/DBusEntrypoint.js';
+export { DBusObjectManager } from '../components/DBusObjectManager.js';
+//The DBus client
+export { DBusClientComponent, buildDBusClientOptions } from '../components/DBusClientComponent.js';
+//The DBus SDK
+export { DBus, DBusInterface as DBusRemoteInterface, DBusObject, DBusService, LocalInterface, LocalObject, LocalService, createDBusError, DBusSignedValue, DBusSignalEmitter, Signature, RequestNameFlags, RequestNameResultCode } from 'dbus-sdk';

package/dist/esm/lib/DBusClientOptions.js

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

package/dist/esm/lib/Declarations.js

@@ -0,0 +1,107 @@
+import { DTO } from '@lakutata/core';
+import { checkInterfaceName, checkMemberName, checkPathTemplate } from './Names.js';
+import { schemaSignature } from './Signature.js';
+/**
+ * Declare a D-Bus signal, to list in the `signals` of one or more `@DBusInterface`. The signal has one argument: a
+ * dictionary of variants (`a{sv}`) holding a DTO, or a value of the signature given. Its data is validated by its DTO
+ * when it is emitted.
+ * @typeParam T The data the signal carries.
+ * @param name The member name of the signal (`'Changed'`): letters, digits and `_`, not starting with a digit; 255
+ * characters at most.
+ * @param data The DTO of the signal's data, or the D-Bus signature of its argument (`'s'`, `'a{sv}'`…); with a
+ * signature, the data is not validated. `'a{sv}'` by default.
+ * @returns The signal's definition.
+ * @throws {TypeError} When the name is invalid.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {defineDBusSignal, type DBusObjectManager} from '@lakutata/dbus'
+ *
+ * class StatusDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ *
+ *     @Expect(DTO.Boolean().required())
+ *     public online: boolean
+ * }
+ *
+ * //A dictionary of variants a{sv}, validated by StatusDTO
+ * export const DeviceChanged = defineDBusSignal<StatusDTO>('Changed', StatusDTO)
+ * //A string s
+ * export const DeviceMessage = defineDBusSignal<string>('Message', 's')
+ *
+ * declare const manager: DBusObjectManager
+ * manager.emitSignal('/com/example/Devices/A1', DeviceChanged, {sn: 'A1', online: true} as StatusDTO)
+ * manager.emitSignal('/com/example/Devices/A1', DeviceMessage, 'Rebooted')
+ * ```
+ */
+export function defineDBusSignal(name, data = 'a{sv}') {
+    checkMemberName(name, 'signal');
+    const isDTO = typeof data === 'function';
+    return {
+        kind: 'signal',
+        name: name,
+        type: isDTO ? schemaSignature(data) : data,
+        validate: (value) => isDTO ? data.validate(value) : value
+    };
+}
+/**
+ * Declare a D-Bus property, to list in the `properties` of one or more `@DBusInterface`. Its values are kept by
+ * `DBusObjectManager`, one per object: the application sets them, the clients read them (`Get`, `GetAll`) and are told
+ * of their changes (`PropertiesChanged`), and write them when the property is writable.
+ * @typeParam T The values of the property.
+ * @param name The member name of the property (`'State'`): letters, digits and `_`, not starting with a digit; 255
+ * characters at most.
+ * @param type The D-Bus signature of its values (`'s'`, `'i'`, `'b'`, `'a{sv}'`…); it is not checked against `schema`.
+ * @param options Whether the clients may write it, its initial value and the schema of its values; none by default
+ * (read-only, no initial value, every value accepted).
+ * @returns The property's definition.
+ * @throws {TypeError} When the name is invalid.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {defineDBusProperty, type DBusObjectManager, type DBusPropertyWrite} from '@lakutata/dbus'
+ *
+ * //Read-only, "idle" until it is set
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ * //Written by the clients, from 0 to 10
+ * export const DeviceLevel = defineDBusProperty<number>('Level', 'i', {writable: true, initial: 1, schema: DTO.Number().integer().min(0).max(10)})
+ *
+ * declare const manager: DBusObjectManager
+ * manager.setPropertyValue('/com/example/Devices/A1', DeviceState, 'running')
+ * manager.on('propertyWritten', (write: DBusPropertyWrite): void => {
+ *     if (write.property === DeviceLevel) console.log(`${write.path}: level ${write.value}`)
+ * })
+ * ```
+ */
+export function defineDBusProperty(name, type, options = {}) {
+    checkMemberName(name, 'property');
+    const schema = options.schema;
+    return {
+        kind: 'property',
+        name: name,
+        type: type,
+        writable: options.writable === true,
+        initial: options.initial,
+        validate: (value) => schema ? DTO.validate(value, schema) : value
+    };
+}
+const DBUS_INTERFACE = Symbol('DBUS.INTERFACE');
+/**
+ * Keep the declaration of the interface of a controller
+ * @param controller
+ * @param declaration
+ */
+export function setDBusInterfaceDeclaration(controller, declaration) {
+    checkInterfaceName(declaration.interface);
+    checkPathTemplate(declaration.path);
+    Reflect.defineMetadata(DBUS_INTERFACE, declaration, controller);
+}
+/**
+ * The declaration of the interface of a controller, or of its nearest parent class declaring one
+ * @param controller
+ */
+export function getDBusInterfaceDeclaration(controller) {
+    return Reflect.getMetadata(DBUS_INTERFACE, controller);
+}

package/dist/esm/lib/Names.js

@@ -0,0 +1,73 @@
+/**
+ * The names of the interfaces and of the errors: dot-separated elements
+ */
+const INTERFACE_NAME = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)+$/;
+/**
+ * The names of the members: the methods, the properties and the signals
+ */
+const MEMBER_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * The object paths, their elements may be variables of a template ("/com/example/Devices/{sn}")
+ */
+const PATH_TEMPLATE = /^\/$|^(\/([A-Za-z0-9_]+|\{[A-Za-z_][A-Za-z0-9_]*}))+$/;
+/**
+ * Check the name of an interface
+ * @param name
+ */
+export function checkInterfaceName(name) {
+    if (typeof name !== 'string' || name.length > 255 || !INTERFACE_NAME.test(name))
+        throw new TypeError(`Invalid DBus interface name "${name}": dot-separated elements of letters, digits and "_", such as "com.example.Device"`);
+    return name;
+}
+/**
+ * Check the name of a member
+ * @param name
+ * @param kind
+ */
+export function checkMemberName(name, kind) {
+    if (typeof name !== 'string' || name.length > 255 || !MEMBER_NAME.test(name))
+        throw new TypeError(`Invalid DBus ${kind} name "${name}": letters, digits and "_", not starting with a digit`);
+    return name;
+}
+/**
+ * Check an object path, or a template of object paths
+ * @param path
+ */
+export function checkPathTemplate(path) {
+    if (typeof path !== 'string' || !PATH_TEMPLATE.test(path))
+        throw new TypeError(`Invalid DBus object path "${path}": "/" separated elements of letters, digits and "_", or variables such as "{sn}"`);
+    return path;
+}
+/**
+ * Compile a template of object paths
+ * @param template
+ */
+export function compilePathTemplate(template) {
+    const variables = [];
+    const expression = new RegExp(`^${checkPathTemplate(template).replace(/\{([A-Za-z_][A-Za-z0-9_]*)}/g, (matched, name) => {
+        variables.push(name);
+        return '([A-Za-z0-9_]+)';
+    })}$`);
+    return {
+        template: template,
+        variables: variables,
+        static: !variables.length,
+        match: (path) => {
+            const matched = expression.exec(path);
+            return matched ? Object.fromEntries(variables.map((name, index) => [name, matched[index + 1]])) : undefined;
+        }
+    };
+}
+/**
+ * The name of the DBus error of an exception: its errno, or its name
+ * @param error
+ */
+export function errorName(error) {
+    const { errno, name } = (error && typeof error === 'object' ? error : {});
+    const candidate = String(errno ?? name ?? 'Error');
+    //A dotted name is a full DBus error name, the others are prefixed by the service name
+    if (INTERFACE_NAME.test(candidate))
+        return candidate;
+    const element = candidate.replace(/[^A-Za-z0-9_]/g, '_');
+    return /^[A-Za-z_]/.test(element) ? element : `E${element}`;
+}

package/dist/esm/lib/Signature.js

@@ -0,0 +1,49 @@
+import { DBusSignedValue } from 'dbus-sdk';
+/**
+ * The DBus signature of the values of a schema: an object is a dictionary of variants,
+ * the scalars have their own types, the other values are variants
+ * @param schema
+ */
+export function schemaSignature(schema) {
+    const target = typeof schema === 'function' ? schema.Schema() : schema;
+    switch (target?.type) {
+        case 'object':
+            return 'a{sv}';
+        case 'string':
+            return 's';
+        case 'boolean':
+            return 'b';
+        case 'number':
+            return (target._rules ?? []).some((rule) => rule.name === 'integer') ? 'x' : 'd';
+        case 'bigint':
+            return 'x';
+        case 'array':
+            return 'av';
+        default:
+            return 'v';
+    }
+}
+/**
+ * A value ready to be encoded: the dates are ISO strings, the undefined and null values are removed (a variant has no null);
+ * the typed values of dbus-sdk (`DBusUInt32`, `DBusVariant`…) are kept as they are, a Map keeps its entries (its keys
+ * keep their types)
+ * @param value
+ */
+export function toEncodable(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof DBusSignedValue)
+        return value;
+    if (Array.isArray(value))
+        return value.filter((item) => item !== undefined && item !== null).map(toEncodable);
+    if (value instanceof Map)
+        return new Map([...value].filter(([, item]) => item !== undefined && item !== null).map(([key, item]) => [key, toEncodable(item)]));
+    if (value && typeof value === 'object' && !Buffer.isBuffer(value) && !(value instanceof Uint8Array)) {
+        const encodable = {};
+        for (const [key, item] of Object.entries(value))
+            if (item !== undefined && item !== null)
+                encodable[key] = toEncodable(item);
+        return encodable;
+    }
+    return value;
+}

package/dist/esm/types/DBusContextParams.js

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