rp2040js 0.17.17 → 0.18.1

package/dist/cjs/utils/time.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatTime = exports.getCurrentMicroseconds = void 0;
-function getCurrentMicroseconds() {
-    if (typeof performance != 'undefined') {
-        return Math.floor(performance.now() * 1000);
-    }
-    else {
-        return Math.floor(eval('require')('perf_hooks').performance.now() * 1000);
-    }
-}
-exports.getCurrentMicroseconds = getCurrentMicroseconds;
-function leftPad(value, minLength, padChar = ' ') {
-    if (value.length < minLength) {
-        value = padChar + value;
-    }
-    return value;
-}
-function rightPad(value, minLength, padChar = ' ') {
-    if (value.length < minLength) {
-        value += padChar;
-    }
-    return value;
-}
-function formatTime(date) {
-    const hours = leftPad(date.getHours().toString(), 2, '0');
-    const minutes = leftPad(date.getMinutes().toString(), 2, '0');
-    const seconds = leftPad(date.getSeconds().toString(), 2, '0');
-    const milliseconds = rightPad(date.getMilliseconds().toString(), 3);
-    return `${hours}:${minutes}:${seconds}.${milliseconds}`;
-}
-exports.formatTime = formatTime;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTime = exports.getCurrentMicroseconds = void 0;
+function getCurrentMicroseconds() {
+    if (typeof performance != 'undefined') {
+        return Math.floor(performance.now() * 1000);
+    }
+    else {
+        return Math.floor(eval('require')('perf_hooks').performance.now() * 1000);
+    }
+}
+exports.getCurrentMicroseconds = getCurrentMicroseconds;
+function leftPad(value, minLength, padChar = ' ') {
+    if (value.length < minLength) {
+        value = padChar + value;
+    }
+    return value;
+}
+function rightPad(value, minLength, padChar = ' ') {
+    if (value.length < minLength) {
+        value += padChar;
+    }
+    return value;
+}
+function formatTime(date) {
+    const hours = leftPad(date.getHours().toString(), 2, '0');
+    const minutes = leftPad(date.getMinutes().toString(), 2, '0');
+    const seconds = leftPad(date.getSeconds().toString(), 2, '0');
+    const milliseconds = rightPad(date.getMilliseconds().toString(), 3);
+    return `${hours}:${minutes}:${seconds}.${milliseconds}`;
+}
+exports.formatTime = formatTime;

package/dist/cjs/utils/timer32.d.ts

@@ -1,57 +1,57 @@
-import { IClock } from '../clock/clock';
-export declare enum TimerMode {
-    Increment = 0,
-    Decrement = 1,
-    ZigZag = 2
-}
-export declare class Timer32 {
-    readonly clock: IClock;
-    private baseFreq;
-    private baseValue;
-    private baseMicros;
-    private topValue;
-    private prescalerValue;
-    private timerMode;
-    private enabled;
-    readonly listeners: (() => void)[];
-    constructor(clock: IClock, baseFreq: number);
-    reset(): void;
-    set(value: number, zigZagDown?: boolean): void;
-    /**
-     * Advances the counter by the given amount. Note that this will
-     * decrease the counter if the timer is running in Decrement mode.
-     *
-     * @param delta The value to add to the counter. Can be negative.
-     */
-    advance(delta: number): void;
-    get rawCounter(): number;
-    get counter(): number;
-    get top(): number;
-    set top(value: number);
-    get frequency(): number;
-    set frequency(value: number);
-    get prescaler(): number;
-    set prescaler(value: number);
-    toMicros(cycles: number): number;
-    get enable(): boolean;
-    set enable(value: boolean);
-    get mode(): TimerMode;
-    set mode(value: TimerMode);
-    private updated;
-}
-export declare class Timer32PeriodicAlarm {
-    readonly timer: Timer32;
-    readonly callback: () => void;
-    private targetValue;
-    private enabled;
-    private clockTimer?;
-    constructor(timer: Timer32, callback: () => void);
-    get enable(): boolean;
-    set enable(value: boolean);
-    get target(): number;
-    set target(value: number);
-    handleAlarm: () => void;
-    update: () => void;
-    private schedule;
-    private cancel;
-}
+import { IClock } from '../clock/clock.js';
+export declare enum TimerMode {
+    Increment = 0,
+    Decrement = 1,
+    ZigZag = 2
+}
+export declare class Timer32 {
+    readonly clock: IClock;
+    private baseFreq;
+    private baseValue;
+    private baseMicros;
+    private topValue;
+    private prescalerValue;
+    private timerMode;
+    private enabled;
+    readonly listeners: (() => void)[];
+    constructor(clock: IClock, baseFreq: number);
+    reset(): void;
+    set(value: number, zigZagDown?: boolean): void;
+    /**
+     * Advances the counter by the given amount. Note that this will
+     * decrease the counter if the timer is running in Decrement mode.
+     *
+     * @param delta The value to add to the counter. Can be negative.
+     */
+    advance(delta: number): void;
+    get rawCounter(): number;
+    get counter(): number;
+    get top(): number;
+    set top(value: number);
+    get frequency(): number;
+    set frequency(value: number);
+    get prescaler(): number;
+    set prescaler(value: number);
+    toMicros(cycles: number): number;
+    get enable(): boolean;
+    set enable(value: boolean);
+    get mode(): TimerMode;
+    set mode(value: TimerMode);
+    private updated;
+}
+export declare class Timer32PeriodicAlarm {
+    readonly timer: Timer32;
+    readonly callback: () => void;
+    private targetValue;
+    private enabled;
+    private clockTimer?;
+    constructor(timer: Timer32, callback: () => void);
+    get enable(): boolean;
+    set enable(value: boolean);
+    get target(): number;
+    set target(value: number);
+    handleAlarm: () => void;
+    update: () => void;
+    private schedule;
+    private cancel;
+}

package/dist/cjs/utils/timer32.js

@@ -1,208 +1,208 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Timer32PeriodicAlarm = exports.Timer32 = exports.TimerMode = void 0;
-var TimerMode;
-(function (TimerMode) {
-    TimerMode[TimerMode["Increment"] = 0] = "Increment";
-    TimerMode[TimerMode["Decrement"] = 1] = "Decrement";
-    TimerMode[TimerMode["ZigZag"] = 2] = "ZigZag";
-})(TimerMode = exports.TimerMode || (exports.TimerMode = {}));
-class Timer32 {
-    constructor(clock, baseFreq) {
-        this.clock = clock;
-        this.baseFreq = baseFreq;
-        this.baseValue = 0;
-        this.baseMicros = 0;
-        this.topValue = 0xffffffff;
-        this.prescalerValue = 1;
-        this.timerMode = TimerMode.Increment;
-        this.enabled = true;
-        this.listeners = [];
-    }
-    reset() {
-        this.baseMicros = this.clock.micros;
-        this.baseValue = 0;
-        this.updated();
-    }
-    set(value, zigZagDown = false) {
-        this.baseValue = zigZagDown ? this.topValue * 2 - value : value;
-        this.baseMicros = this.clock.micros;
-        this.updated();
-    }
-    /**
-     * Advances the counter by the given amount. Note that this will
-     * decrease the counter if the timer is running in Decrement mode.
-     *
-     * @param delta The value to add to the counter. Can be negative.
-     */
-    advance(delta) {
-        this.baseValue += delta;
-    }
-    get rawCounter() {
-        const { baseFreq, prescalerValue, baseMicros, baseValue, enabled, timerMode } = this;
-        if (!baseFreq || !prescalerValue || !enabled) {
-            return this.baseValue;
-        }
-        const zigzag = timerMode == TimerMode.ZigZag;
-        const ticks = ((this.clock.micros - baseMicros) / 1e6) * (baseFreq / prescalerValue);
-        const topModulo = zigzag ? this.topValue * 2 : this.topValue + 1;
-        const delta = timerMode == TimerMode.Decrement ? topModulo - (ticks % topModulo) : ticks;
-        let currentValue = Math.round(baseValue + delta);
-        if (this.topValue != 0xffffffff) {
-            currentValue %= topModulo;
-        }
-        return currentValue;
-    }
-    get counter() {
-        let currentValue = this.rawCounter;
-        if (this.timerMode == TimerMode.ZigZag && currentValue > this.topValue) {
-            currentValue = this.topValue * 2 - currentValue;
-        }
-        return currentValue >>> 0;
-    }
-    get top() {
-        return this.topValue;
-    }
-    set top(value) {
-        const { counter } = this;
-        this.topValue = value;
-        this.set(counter <= this.topValue ? counter : 0);
-    }
-    get frequency() {
-        return this.baseFreq;
-    }
-    set frequency(value) {
-        this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
-        this.baseFreq = value;
-        this.updated();
-    }
-    get prescaler() {
-        return this.prescalerValue;
-    }
-    set prescaler(value) {
-        this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
-        this.enabled = this.prescalerValue !== 0;
-        this.prescalerValue = value;
-        this.updated();
-    }
-    toMicros(cycles) {
-        const { baseFreq, prescalerValue } = this;
-        return (cycles * 1e6) / (baseFreq / prescalerValue);
-    }
-    get enable() {
-        return this.enabled;
-    }
-    set enable(value) {
-        if (value !== this.enabled) {
-            if (value) {
-                this.baseMicros = this.clock.micros;
-            }
-            else {
-                this.baseValue = this.counter;
-            }
-            this.enabled = value;
-            this.updated();
-        }
-    }
-    get mode() {
-        return this.timerMode;
-    }
-    set mode(value) {
-        if (this.timerMode !== value) {
-            const { counter } = this;
-            this.timerMode = value;
-            this.set(counter);
-        }
-    }
-    updated() {
-        for (const listener of this.listeners) {
-            listener();
-        }
-    }
-}
-exports.Timer32 = Timer32;
-class Timer32PeriodicAlarm {
-    constructor(timer, callback) {
-        this.timer = timer;
-        this.callback = callback;
-        this.targetValue = 0;
-        this.enabled = false;
-        this.handleAlarm = () => {
-            this.callback();
-            if (this.enabled && this.timer.enable) {
-                this.schedule();
-            }
-        };
-        this.update = () => {
-            this.cancel();
-            if (this.enabled && this.timer.enable) {
-                this.schedule();
-            }
-        };
-        timer.listeners.push(this.update);
-    }
-    get enable() {
-        return this.enabled;
-    }
-    set enable(value) {
-        if (value !== this.enabled) {
-            this.enabled = value;
-            if (value && this.timer.enable) {
-                this.schedule();
-            }
-            else {
-                this.cancel();
-            }
-        }
-    }
-    get target() {
-        return this.targetValue;
-    }
-    set target(value) {
-        if (value === this.targetValue) {
-            return;
-        }
-        this.targetValue = value;
-        if (this.enabled && this.timer.enable) {
-            this.cancel();
-            this.schedule();
-        }
-    }
-    schedule() {
-        const { timer, targetValue } = this;
-        const { top, mode, rawCounter } = timer;
-        let cycleDelta = targetValue - rawCounter;
-        if (mode === TimerMode.ZigZag && cycleDelta < 0) {
-            if (cycleDelta < -top) {
-                cycleDelta += 2 * top;
-            }
-            else {
-                cycleDelta = top * 2 - targetValue - rawCounter;
-            }
-        }
-        if (top != 0xffffffff) {
-            if (cycleDelta < 0) {
-                cycleDelta += top + 1;
-            }
-            if (targetValue > top) {
-                // Skip alarm
-                return;
-            }
-        }
-        if (mode === TimerMode.Decrement) {
-            cycleDelta = top + 1 - cycleDelta;
-        }
-        const cyclesToAlarm = cycleDelta >>> 0;
-        const microsToAlarm = timer.toMicros(cyclesToAlarm);
-        this.clockTimer = this.timer.clock.createTimer(microsToAlarm, this.handleAlarm);
-    }
-    cancel() {
-        if (this.clockTimer) {
-            this.timer.clock.deleteTimer(this.clockTimer);
-            this.clockTimer = undefined;
-        }
-    }
-}
-exports.Timer32PeriodicAlarm = Timer32PeriodicAlarm;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer32PeriodicAlarm = exports.Timer32 = exports.TimerMode = void 0;
+var TimerMode;
+(function (TimerMode) {
+    TimerMode[TimerMode["Increment"] = 0] = "Increment";
+    TimerMode[TimerMode["Decrement"] = 1] = "Decrement";
+    TimerMode[TimerMode["ZigZag"] = 2] = "ZigZag";
+})(TimerMode || (exports.TimerMode = TimerMode = {}));
+class Timer32 {
+    constructor(clock, baseFreq) {
+        this.clock = clock;
+        this.baseFreq = baseFreq;
+        this.baseValue = 0;
+        this.baseMicros = 0;
+        this.topValue = 0xffffffff;
+        this.prescalerValue = 1;
+        this.timerMode = TimerMode.Increment;
+        this.enabled = true;
+        this.listeners = [];
+    }
+    reset() {
+        this.baseMicros = this.clock.micros;
+        this.baseValue = 0;
+        this.updated();
+    }
+    set(value, zigZagDown = false) {
+        this.baseValue = zigZagDown ? this.topValue * 2 - value : value;
+        this.baseMicros = this.clock.micros;
+        this.updated();
+    }
+    /**
+     * Advances the counter by the given amount. Note that this will
+     * decrease the counter if the timer is running in Decrement mode.
+     *
+     * @param delta The value to add to the counter. Can be negative.
+     */
+    advance(delta) {
+        this.baseValue += delta;
+    }
+    get rawCounter() {
+        const { baseFreq, prescalerValue, baseMicros, baseValue, enabled, timerMode } = this;
+        if (!baseFreq || !prescalerValue || !enabled) {
+            return this.baseValue;
+        }
+        const zigzag = timerMode == TimerMode.ZigZag;
+        const ticks = ((this.clock.micros - baseMicros) / 1e6) * (baseFreq / prescalerValue);
+        const topModulo = zigzag ? this.topValue * 2 : this.topValue + 1;
+        const delta = timerMode == TimerMode.Decrement ? topModulo - (ticks % topModulo) : ticks;
+        let currentValue = Math.round(baseValue + delta);
+        if (this.topValue != 0xffffffff) {
+            currentValue %= topModulo;
+        }
+        return currentValue;
+    }
+    get counter() {
+        let currentValue = this.rawCounter;
+        if (this.timerMode == TimerMode.ZigZag && currentValue > this.topValue) {
+            currentValue = this.topValue * 2 - currentValue;
+        }
+        return currentValue >>> 0;
+    }
+    get top() {
+        return this.topValue;
+    }
+    set top(value) {
+        const { counter } = this;
+        this.topValue = value;
+        this.set(counter <= this.topValue ? counter : 0);
+    }
+    get frequency() {
+        return this.baseFreq;
+    }
+    set frequency(value) {
+        this.baseValue = this.counter;
+        this.baseMicros = this.clock.micros;
+        this.baseFreq = value;
+        this.updated();
+    }
+    get prescaler() {
+        return this.prescalerValue;
+    }
+    set prescaler(value) {
+        this.baseValue = this.counter;
+        this.baseMicros = this.clock.micros;
+        this.enabled = this.prescalerValue !== 0;
+        this.prescalerValue = value;
+        this.updated();
+    }
+    toMicros(cycles) {
+        const { baseFreq, prescalerValue } = this;
+        return (cycles * 1e6) / (baseFreq / prescalerValue);
+    }
+    get enable() {
+        return this.enabled;
+    }
+    set enable(value) {
+        if (value !== this.enabled) {
+            if (value) {
+                this.baseMicros = this.clock.micros;
+            }
+            else {
+                this.baseValue = this.counter;
+            }
+            this.enabled = value;
+            this.updated();
+        }
+    }
+    get mode() {
+        return this.timerMode;
+    }
+    set mode(value) {
+        if (this.timerMode !== value) {
+            const { counter } = this;
+            this.timerMode = value;
+            this.set(counter);
+        }
+    }
+    updated() {
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+}
+exports.Timer32 = Timer32;
+class Timer32PeriodicAlarm {
+    constructor(timer, callback) {
+        this.timer = timer;
+        this.callback = callback;
+        this.targetValue = 0;
+        this.enabled = false;
+        this.handleAlarm = () => {
+            this.callback();
+            if (this.enabled && this.timer.enable) {
+                this.schedule();
+            }
+        };
+        this.update = () => {
+            this.cancel();
+            if (this.enabled && this.timer.enable) {
+                this.schedule();
+            }
+        };
+        timer.listeners.push(this.update);
+    }
+    get enable() {
+        return this.enabled;
+    }
+    set enable(value) {
+        if (value !== this.enabled) {
+            this.enabled = value;
+            if (value && this.timer.enable) {
+                this.schedule();
+            }
+            else {
+                this.cancel();
+            }
+        }
+    }
+    get target() {
+        return this.targetValue;
+    }
+    set target(value) {
+        if (value === this.targetValue) {
+            return;
+        }
+        this.targetValue = value;
+        if (this.enabled && this.timer.enable) {
+            this.cancel();
+            this.schedule();
+        }
+    }
+    schedule() {
+        const { timer, targetValue } = this;
+        const { top, mode, rawCounter } = timer;
+        let cycleDelta = targetValue - rawCounter;
+        if (mode === TimerMode.ZigZag && cycleDelta < 0) {
+            if (cycleDelta < -top) {
+                cycleDelta += 2 * top;
+            }
+            else {
+                cycleDelta = top * 2 - targetValue - rawCounter;
+            }
+        }
+        if (top != 0xffffffff) {
+            if (cycleDelta < 0) {
+                cycleDelta += top + 1;
+            }
+            if (targetValue > top) {
+                // Skip alarm
+                return;
+            }
+        }
+        if (mode === TimerMode.Decrement) {
+            cycleDelta = top + 1 - cycleDelta;
+        }
+        const cyclesToAlarm = cycleDelta >>> 0;
+        const microsToAlarm = timer.toMicros(cyclesToAlarm);
+        this.clockTimer = this.timer.clock.createTimer(microsToAlarm, this.handleAlarm);
+    }
+    cancel() {
+        if (this.clockTimer) {
+            this.timer.clock.deleteTimer(this.clockTimer);
+            this.clockTimer = undefined;
+        }
+    }
+}
+exports.Timer32PeriodicAlarm = Timer32PeriodicAlarm;

package/dist/esm/clock/clock.d.ts

@@ -1,11 +1,11 @@
-export interface IClockTimer {
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export interface IClock {
-    readonly micros: number;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
-    deleteTimer(timer: IClockTimer): void;
-}
+export interface IClockTimer {
+    pause(currentMicros: number): void;
+    resume(currentMicros: number): void;
+}
+export interface IClock {
+    readonly micros: number;
+    pause(): void;
+    resume(): void;
+    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
+    deleteTimer(timer: IClockTimer): void;
+}

package/dist/esm/clock/clock.js

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

package/dist/esm/clock/mock-clock.d.ts

@@ -1,17 +1,17 @@
-import { IClock, IClockTimer } from './clock';
-export declare class MockClockTimer implements IClockTimer {
-    readonly micros: number;
-    readonly callback: () => void;
-    constructor(micros: number, callback: () => void);
-    pause(): void;
-    resume(): void;
-}
-export declare class MockClock implements IClock {
-    micros: number;
-    readonly timers: MockClockTimer[];
-    pause(): void;
-    resume(): void;
-    advance(deltaMicros: number): void;
-    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
-    deleteTimer(timer: IClockTimer): void;
-}
+import { IClock, IClockTimer } from './clock.js';
+export declare class MockClockTimer implements IClockTimer {
+    readonly micros: number;
+    readonly callback: () => void;
+    constructor(micros: number, callback: () => void);
+    pause(): void;
+    resume(): void;
+}
+export declare class MockClock implements IClock {
+    micros: number;
+    readonly timers: MockClockTimer[];
+    pause(): void;
+    resume(): void;
+    advance(deltaMicros: number): void;
+    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
+    deleteTimer(timer: IClockTimer): void;
+}