@seriousme/opifex 1.6.3 → 1.7.0

package/dist/server/mod.js

@@ -1,7 +0,0 @@
-/**
- *  This module provides an MQTT Server interface see the /bin folder for examples
- *  @module
- */
-export { AuthenticationResult } from "./deps.js";
-export { MqttServer } from "./server.js";
-export { Context } from "./context.js";

package/dist/server/server.js

@@ -1,47 +0,0 @@
-import { Context } from "./context.js";
-import { AuthenticationResult, logger, MemoryPersistence, } from "./deps.js";
-import { handlePacket } from "./handlers/handlePacket.js";
-const defaultIsAuthenticated = (_ctx, _clientId, _username, _password) => AuthenticationResult.ok;
-const defaultIsAuthorized = (_ctx, _topic) => true;
-/** The MqttServer class provides a MQTT server with configurable persistence and
- * authentication/authorization handlers.
- *
- * The default handlers are:
- *  - isAuthenticated: always returns ok
- *  - isAuthorizedToPublish: always returns true
- *  - isAuthorizedToSubscribe: always returns true
- *
- * To customize the handlers, pass in a Handlers object.
- * To customize the persistence, pass in a Persistence object.
- */
-export class MqttServer {
-    handlers;
-    persistence;
-    constructor({ persistence, handlers, }) {
-        this.persistence = persistence || new MemoryPersistence();
-        this.handlers = {
-            isAuthenticated: handlers?.isAuthenticated || defaultIsAuthenticated,
-            isAuthorizedToPublish: handlers?.isAuthorizedToPublish ||
-                defaultIsAuthorized,
-            isAuthorizedToSubscribe: handlers?.isAuthorizedToSubscribe ||
-                defaultIsAuthorized,
-        };
-    }
-    async serve(conn) {
-        const ctx = new Context(this.persistence, conn, this.handlers);
-        if (conn.remoteAddr?.transport === "tcp") {
-            logger.debug(`socket connected from ${conn.remoteAddr.hostname}`);
-        }
-        try {
-            for await (const packet of ctx.mqttConn) {
-                handlePacket(ctx, packet);
-            }
-        }
-        catch (err) {
-            logger.debug(`Error while serving:${err}`);
-        }
-        finally {
-            ctx.close();
-        }
-    }
-}

package/dist/socket/socket.js

@@ -1,36 +0,0 @@
-export class Conn {
-    reader;
-    writer;
-    closed;
-    remoteAddr;
-    closer;
-    constructor(sockConn) {
-        this.closed = false;
-        this.reader = sockConn.readable.getReader({ mode: "byob" });
-        this.writer = sockConn.writable.getWriter();
-        // this.writer.closed.then(() => this.closed = true);
-        this.closer = sockConn.close.bind(sockConn);
-        this.remoteAddr = sockConn.remoteAddr;
-    }
-    async read(buff) {
-        const buff2 = new Uint8Array(buff.length);
-        const result = await this.reader.read(buff2);
-        if (!result.done) {
-            buff.set(result.value);
-        }
-        return result.value?.byteLength || null;
-    }
-    write(data) {
-        if (this.closed) {
-            return Promise.reject();
-        }
-        this.writer.write(data);
-        return new Promise((resolve) => resolve(data.length));
-    }
-    close() {
-        if (!this.closed) {
-            this.closed = true;
-            this.closer();
-        }
-    }
-}

package/dist/timer/timer.js

@@ -1,40 +0,0 @@
-export class Timer {
-    delay; // delay in microseconds
-    // deno-lint-ignore ban-types
-    action; // function to perform when timer expires
-    timer;
-    end = 0;
-    running = false;
-    // deno-lint-ignore ban-types
-    constructor(action, delay, wait = false) {
-        this.delay = delay;
-        this.action = action;
-        if (!wait) {
-            this.reset();
-        }
-    }
-    startTimer(delay) {
-        this.running = true;
-        this.timer = setTimeout(() => this.ring(), delay);
-    }
-    ring() {
-        const timeLeft = this.end - Date.now();
-        // check if delay has passed, else execute action
-        if (timeLeft > 0) {
-            this.startTimer(timeLeft);
-            return;
-        }
-        this.running = false;
-        this.action();
-    }
-    reset() {
-        this.end = Date.now() + this.delay;
-        if (!this.running) {
-            this.startTimer(this.delay);
-        }
-    }
-    clear() {
-        clearTimeout(this.timer);
-        this.running = false;
-    }
-}

package/dist/trie/trie.js

@@ -1,95 +0,0 @@
-export class Trie {
-    #value;
-    #children;
-    separator = "/";
-    wildcardOne = "+";
-    wildcardSubtree = "#";
-    reservedPrefix = "$";
-    looseCompare;
-    constructor(looseCompare = false) {
-        this.#value = [];
-        this.#children = new Map();
-        this.looseCompare = looseCompare;
-    }
-    matchChild(child, parts) {
-        const childNode = this.#children.get(child);
-        return childNode ? childNode._match(parts) : [];
-    }
-    match(key) {
-        const parts = key.split(this.separator);
-        // toplevel wildcards are not allowed to match toplevel reserved topics
-        if (parts.length > 0 && parts[0].charAt(0) === this.reservedPrefix) {
-            return this._matchPrefix(parts);
-        }
-        return this._match(parts);
-    }
-    _matchPrefix(parts) {
-        if (parts.length === 0) {
-            return this.#value ? this.#value : [];
-        }
-        const [first, ...rest] = parts;
-        return this.matchChild(first, rest);
-    }
-    _match(parts) {
-        if (parts.length === 0) {
-            return this.#value ? this.#value : [];
-        }
-        const [first, ...rest] = parts;
-        const exact = this.matchChild(first, rest);
-        const single = this.matchChild(this.wildcardOne, rest);
-        const subtree = this.matchChild(this.wildcardSubtree, []);
-        const results = exact.concat(single, subtree);
-        return results;
-    }
-    add(key, value) {
-        return this._add(key.split(this.separator), value);
-    }
-    _add(parts, value) {
-        if (parts.length === 0) {
-            this.#value = this.#value.concat(value);
-            return;
-        }
-        const [first, ...rest] = parts;
-        const child = this.#children.get(first);
-        if (child instanceof Trie) {
-            child._add(rest, value);
-        }
-        else {
-            const node = new Trie(this.looseCompare);
-            this.#children.set(first, node);
-            node._add(rest, value);
-        }
-        return;
-    }
-    remove(key, value) {
-        return this._remove(key.split(this.separator), value);
-    }
-    _remove(parts, value) {
-        if (parts.length === 0) {
-            const arr = this.#value || [];
-            this.#value = arr.filter(this.filter(value));
-            return;
-        }
-        const [first, ...rest] = parts;
-        const node = this.#children.get(first);
-        if (node) {
-            node._remove(rest, value);
-            if (node.#value.length === 0 && this.#children.size === 0) {
-                this.#children.delete(first);
-            }
-        }
-    }
-    filter(value) {
-        if (this.looseCompare && typeof value === "object") {
-            return (item) => {
-                for (const key in value) {
-                    if (value[key] !== item[key]) {
-                        return true;
-                    }
-                }
-                return false;
-            };
-        }
-        return (item) => item !== value;
-    }
-}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../bin/conformanceServer.ts","../bin/demoServer.ts","../bin/mqtt.ts"],"version":"5.7.3"}

package/dist/utils/args.js

@@ -1,75 +0,0 @@
-function formatValue(key, value, boolean, string) {
-    if (key === "__proto__" || key === "constructor") {
-        throw new Error(`Invalid argument: ${key}`);
-    }
-    if (boolean.includes(key)) {
-        if (value !== "false") {
-            return true;
-        }
-        return false;
-    }
-    if (!string.includes(key)) {
-        const num = Number(value);
-        if (!Number.isNaN(num)) {
-            return num;
-        }
-    }
-    return value;
-}
-function parseKeyValue(arg, alias) {
-    if (arg.startsWith("--no-")) {
-        const key = arg.slice(5);
-        return [key, false];
-    }
-    if (arg.startsWith("--")) {
-        const [key, value] = arg.slice(2).split("=", 2);
-        return [key, value];
-    }
-    if (arg.startsWith("-")) {
-        const [flag, value] = arg.slice(1).split("=", 2);
-        const key = alias[flag] || flag;
-        return [key, value];
-    }
-    return ["_", arg];
-}
-/**
- *  a parser for command line arguments
- * @param args the arguments to parse
- * @param opts the options for the parser
- * @returns the parsed arguments
- *
- * @example
- * const args = parseArgs(args, {
- *  alias: { h: "help" },
- *  boolean: ["help"],
- *  string: ["port"],
- *  default: { port: 3000 },
- * });
- */
-export function parseArgs(args, opts = {}) {
-    const { alias = {}, boolean = [], string = [], default: defaults = {} } = opts;
-    const result = { ...defaults };
-    result["_"] = [];
-    for (let i = 0; i < args.length; i++) {
-        const [key, value] = parseKeyValue(args[i], alias);
-        if (key === "_") {
-            result["_"].push(formatValue(key, value, boolean, string));
-            continue;
-        }
-        if (value === undefined) {
-            const nextArg = args[i + 1];
-            if (nextArg !== undefined &&
-                !nextArg.startsWith("-") &&
-                !boolean.includes(key)) {
-                result[key] = formatValue(key, nextArg, boolean, string);
-                i++;
-            }
-            else {
-                result[key] = formatValue(key, value, boolean, string);
-            }
-            continue;
-        }
-        result[key] = formatValue(key, value, boolean, string);
-    }
-    return result;
-}

package/dist/utils/assert.js

@@ -1,20 +0,0 @@
-export class AssertionError extends Error {
-    /** Constructs a new instance. */
-    constructor(message) {
-        super(message);
-        this.name = "AssertionError";
-    }
-}
-/** assert(expr, msg) throws AssertionError if expr is falsy. */
-export function assert(expr, msg = "") {
-    if (!expr) {
-        throw new AssertionError(msg);
-    }
-}
-export function assertArrayIncludes(actual, expected, msg) {
-    const actualArr = Array.from(actual);
-    const expectedArr = Array.from(expected);
-    for (const item of expectedArr) {
-        assert(actualArr.includes(item), msg + `\nExpected: ${expectedArr}\nActual: ${actualArr}`);
-    }
-}

package/dist/utils/asyncQueue.js

@@ -1,69 +0,0 @@
-import { nextTick } from "./nextTick.js";
-/**
- * An Async Queue is a queue that can be used to push items to it and then wait
- * for them to be consumed.
- *
- * @example
- * ```ts
- * const queue = new AsyncQueue<string>();
- * queue.push("hello");
- * for await (const item of queue) {
- *   console.log(item); // "hello"
- * }
- * ```
- */
-export class AsyncQueue {
-    queue = [];
-    maxQueueLength = Infinity;
-    nextResolve = (_value) => { };
-    nextReject = (_reason) => { };
-    done = false;
-    hasNext = false;
-    constructor(maxQueueLength) {
-        if (maxQueueLength) {
-            this.maxQueueLength = maxQueueLength;
-        }
-    }
-    async next() {
-        await nextTick();
-        if (this.done && this.queue.length === 0) {
-            return Promise.reject("Closed");
-        }
-        return new Promise((resolve, reject) => {
-            if (this.queue.length > 0) {
-                const item = this.queue.shift();
-                if (item) {
-                    return resolve(item);
-                }
-            }
-            this.nextResolve = resolve;
-            this.nextReject = reject;
-            this.hasNext = true;
-        });
-    }
-    close(reason = "closed") {
-        this.done = true;
-        if (this.hasNext) {
-            this.nextReject(reason);
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        while (true) {
-            yield this.next();
-        }
-    }
-    push(item) {
-        if (this.hasNext) {
-            this.nextResolve(item);
-            this.hasNext = false;
-            return;
-        }
-        if (this.queue.length > this.maxQueueLength) {
-            this.queue.shift();
-        }
-        this.queue.push(item);
-    }
-    get isDone() {
-        return this.done;
-    }
-}

package/dist/utils/deferred.js

@@ -1,14 +0,0 @@
-/**
- * Create a promise that can be resolved/rejected later
- */
-export class Deferred {
-    promise;
-    resolve;
-    reject;
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-    }
-}

package/dist/utils/logger.js

@@ -1,58 +0,0 @@
-/**
- * The available log levels
- */
-export const LogLevel = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    verbose: 3,
-    debug: 4,
-};
-/**
- * Simple logger class
- * @example
- * ```ts
- * const logger = new Logger();
- * logger.level(LogLevel.debug);
- * logger.debug("debug message");
- * logger.verbose("verbose message");
- * logger.info("info message");
- * logger.warn("warn message");
- * logger.error("error message");
- * ```
- */
-export class Logger {
-    defaultError = console.error;
-    defaultWarn = console.warn;
-    defaultInfo = console.info;
-    defaultVerbose = console.log;
-    defaultDebug = console.log;
-    // deno-lint-ignore no-explicit-any
-    noop = (..._data) => { };
-    error = this.defaultError;
-    warn = this.defaultWarn;
-    info = this.defaultInfo;
-    verbose = this.noop;
-    debug = this.noop;
-    constructor() { }
-    level(logLevel) {
-        this.warn = logLevel > 0 ? this.defaultWarn : this.noop;
-        this.info = logLevel > 1 ? this.defaultInfo : this.noop;
-        this.verbose = logLevel > 2 ? this.defaultVerbose : this.noop;
-        this.debug = logLevel > 3 ? this.defaultDebug : this.noop;
-    }
-}
-/**
- * logger provides a singleton logger instance
- * @example
- * ```ts
- * import { logger } from "./utils/logger.ts";
- * logger.level(LogLevel.debug);
- * logger.debug("debug message");
- * logger.verbose("verbose message");
- * logger.info("info message");
- * logger.warn("warn message");
- * logger.error("error message");
- * ```
- */
-export const logger = new Logger();

package/dist/utils/mod.js

@@ -1,11 +0,0 @@
-/**
- *  This module provides various utilities
- *  @module
- */
-export { assert } from "./assert.js";
-export { Deferred } from "./deferred.js";
-export { Logger, logger, LogLevel } from "./logger.js";
-export { AsyncQueue } from "./asyncQueue.js";
-export { nextTick } from "./nextTick.js";
-export { parseArgs } from "./args.js";
-export { getArgs } from "./platform.js";

package/dist/utils/nextTick.js

@@ -1,18 +0,0 @@
-/**
- * Returns a promise that resolves on the next tick of the Node.js event loop.
- * This is useful for deferring execution of code until after the current call stack is cleared.
- *
- * @example
- * ```ts
- * async function example() {
- *   console.log('Before nextTick');
- *   await nextTick();
- *   console.log('After nextTick');
- * }
- * ```
- *
- * @returns {Promise<void>} A promise that resolves on the next tick of the event loop
- */
-export function nextTick() {
-    return new Promise((resolve) => setTimeout(resolve, 0));
-}

package/dist/utils/platform.js

@@ -1,7 +0,0 @@
-import { argv } from "node:process";
-/**
- * @returns an array of command line arguments
- */
-export function getArgs() {
-    return argv.slice(2);
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    // Node 18
-    "target": "ES2022",
-    "module": "esnext",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "allowImportingTsExtensions": true,
-    "rewriteRelativeImportExtensions": true,
-    "strict": true,
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "isolatedModules": true,
-    "skipLibCheck": true
-  },
-  "include": ["bin/*.ts"],
-  "exclude": [
-    "dist",
-    "deno",
-    "node_modules"
-  ]
-}