kfox/crypto_trader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: Crypto trader application

Browse Source
This commit is contained in:
kfox
2025-12-25 20:20:40 -05:00
commit 07a04c1bb8
47895 changed files with 2042266 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
frontend/node_modules/fancy-canvas/canvas-element-bitmap-size.d.mts generated vendored Normal file
View File

@@ -0,0 +1,35 @@
import Disposable from "./disposable.mjs";
import { Size } from "./size.mjs";
export declare type BitmapSizeChangedListener = (this: Binding, oldSize: Size, newSize: Size) => void;
export declare type BitmapSizeTransformer = (bitmapSize: Size, canvasElementClientSize: Size) => {
width: number;
height: number;
};
export declare type SuggestedBitmapSizeChangedListener = (this: Binding, oldSize: Size | null, newSize: Size | null) => void;
export interface Binding extends Disposable {
readonly canvasElement: HTMLCanvasElement;
/**
* Canvas element client size in CSS pixels
*/
readonly canvasElementClientSize: Size;
resizeCanvasElement(clientSize: {
width: number;
height: number;
}): void;
readonly bitmapSize: Size;
subscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
unsubscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
readonly suggestedBitmapSize: Size | null;
subscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
unsubscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
applySuggestedBitmapSize(): void;
}
export interface DevicePixelContentBoxBindingTargetOptions {
allowResizeObserver?: boolean;
}
export declare type BindingTarget = {
type: 'device-pixel-content-box';
transform?: BitmapSizeTransformer;
options?: DevicePixelContentBoxBindingTargetOptions;
};
export declare function bindTo(canvasElement: HTMLCanvasElement, target: BindingTarget): Binding;

35
frontend/node_modules/fancy-canvas/canvas-element-bitmap-size.d.ts generated vendored Normal file
View File

@@ -0,0 +1,35 @@
import Disposable from './disposable.js';
import { Size } from './size.js';
export declare type BitmapSizeChangedListener = (this: Binding, oldSize: Size, newSize: Size) => void;
export declare type BitmapSizeTransformer = (bitmapSize: Size, canvasElementClientSize: Size) => {
width: number;
height: number;
};
export declare type SuggestedBitmapSizeChangedListener = (this: Binding, oldSize: Size | null, newSize: Size | null) => void;
export interface Binding extends Disposable {
readonly canvasElement: HTMLCanvasElement;
/**
* Canvas element client size in CSS pixels
*/
readonly canvasElementClientSize: Size;
resizeCanvasElement(clientSize: {
width: number;
height: number;
}): void;
readonly bitmapSize: Size;
subscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
unsubscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
readonly suggestedBitmapSize: Size | null;
subscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
unsubscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
applySuggestedBitmapSize(): void;
}
export interface DevicePixelContentBoxBindingTargetOptions {
allowResizeObserver?: boolean;
}
export declare type BindingTarget = {
type: 'device-pixel-content-box';
transform?: BitmapSizeTransformer;
options?: DevicePixelContentBoxBindingTargetOptions;
};
export declare function bindTo(canvasElement: HTMLCanvasElement, target: BindingTarget): Binding;

240
frontend/node_modules/fancy-canvas/canvas-element-bitmap-size.js generated vendored Normal file
View File

@@ -0,0 +1,240 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.bindTo = void 0;
var size_js_1 = require("./size.js");
var device_pixel_ratio_js_1 = require("./device-pixel-ratio.js");
var DevicePixelContentBoxBinding = /** @class */ (function () {
function DevicePixelContentBoxBinding(canvasElement, transformBitmapSize, options) {
var _a;
this._canvasElement = null;
this._bitmapSizeChangedListeners = [];
this._suggestedBitmapSize = null;
this._suggestedBitmapSizeChangedListeners = [];
// devicePixelRatio approach
this._devicePixelRatioObservable = null;
// ResizeObserver approach
this._canvasElementResizeObserver = null;
this._canvasElement = canvasElement;
this._canvasElementClientSize = (0, size_js_1.size)({
width: this._canvasElement.clientWidth,
height: this._canvasElement.clientHeight,
});
this._transformBitmapSize = transformBitmapSize !== null && transformBitmapSize !== void 0 ? transformBitmapSize : (function (size) { return size; });
this._allowResizeObserver = (_a = options === null || options === void 0 ? void 0 : options.allowResizeObserver) !== null && _a !== void 0 ? _a : true;
this._chooseAndInitObserver();
// we MAY leave the constuctor without any bitmap size observation mechanics initialized
}
DevicePixelContentBoxBinding.prototype.dispose = function () {
var _a, _b;
if (this._canvasElement === null) {
throw new Error('Object is disposed');
}
(_a = this._canvasElementResizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
this._canvasElementResizeObserver = null;
(_b = this._devicePixelRatioObservable) === null || _b === void 0 ? void 0 : _b.dispose();
this._devicePixelRatioObservable = null;
this._suggestedBitmapSizeChangedListeners.length = 0;
this._bitmapSizeChangedListeners.length = 0;
this._canvasElement = null;
};
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElement", {
get: function () {
if (this._canvasElement === null) {
throw new Error('Object is disposed');
}
return this._canvasElement;
},
enumerable: false,
configurable: true
});
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElementClientSize", {
get: function () {
return this._canvasElementClientSize;
},
enumerable: false,
configurable: true
});
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "bitmapSize", {
get: function () {
return (0, size_js_1.size)({
width: this.canvasElement.width,
height: this.canvasElement.height,
});
},
enumerable: false,
configurable: true
});
/**
* Use this function to change canvas element client size until binding is disposed
* @param clientSize New client size for bound HTMLCanvasElement
*/
DevicePixelContentBoxBinding.prototype.resizeCanvasElement = function (clientSize) {
this._canvasElementClientSize = (0, size_js_1.size)(clientSize);
this.canvasElement.style.width = "".concat(this._canvasElementClientSize.width, "px");
this.canvasElement.style.height = "".concat(this._canvasElementClientSize.height, "px");
this._invalidateBitmapSize();
};
DevicePixelContentBoxBinding.prototype.subscribeBitmapSizeChanged = function (listener) {
this._bitmapSizeChangedListeners.push(listener);
};
DevicePixelContentBoxBinding.prototype.unsubscribeBitmapSizeChanged = function (listener) {
this._bitmapSizeChangedListeners = this._bitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
};
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "suggestedBitmapSize", {
get: function () {
return this._suggestedBitmapSize;
},
enumerable: false,
configurable: true
});
DevicePixelContentBoxBinding.prototype.subscribeSuggestedBitmapSizeChanged = function (listener) {
this._suggestedBitmapSizeChangedListeners.push(listener);
};
DevicePixelContentBoxBinding.prototype.unsubscribeSuggestedBitmapSizeChanged = function (listener) {
this._suggestedBitmapSizeChangedListeners = this._suggestedBitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
};
DevicePixelContentBoxBinding.prototype.applySuggestedBitmapSize = function () {
if (this._suggestedBitmapSize === null) {
// nothing to apply
return;
}
var oldSuggestedSize = this._suggestedBitmapSize;
this._suggestedBitmapSize = null;
this._resizeBitmap(oldSuggestedSize);
this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, this._suggestedBitmapSize);
};
DevicePixelContentBoxBinding.prototype._resizeBitmap = function (newSize) {
var oldSize = this.bitmapSize;
if ((0, size_js_1.equalSizes)(oldSize, newSize)) {
return;
}
this.canvasElement.width = newSize.width;
this.canvasElement.height = newSize.height;
this._emitBitmapSizeChanged(oldSize, newSize);
};
DevicePixelContentBoxBinding.prototype._emitBitmapSizeChanged = function (oldSize, newSize) {
var _this = this;
this._bitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
};
DevicePixelContentBoxBinding.prototype._suggestNewBitmapSize = function (newSize) {
var oldSuggestedSize = this._suggestedBitmapSize;
var finalNewSize = (0, size_js_1.size)(this._transformBitmapSize(newSize, this._canvasElementClientSize));
var newSuggestedSize = (0, size_js_1.equalSizes)(this.bitmapSize, finalNewSize) ? null : finalNewSize;
if (oldSuggestedSize === null && newSuggestedSize === null) {
return;
}
if (oldSuggestedSize !== null && newSuggestedSize !== null
&& (0, size_js_1.equalSizes)(oldSuggestedSize, newSuggestedSize)) {
return;
}
this._suggestedBitmapSize = newSuggestedSize;
this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, newSuggestedSize);
};
DevicePixelContentBoxBinding.prototype._emitSuggestedBitmapSizeChanged = function (oldSize, newSize) {
var _this = this;
this._suggestedBitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
};
DevicePixelContentBoxBinding.prototype._chooseAndInitObserver = function () {
var _this = this;
if (!this._allowResizeObserver) {
this._initDevicePixelRatioObservable();
return;
}
isDevicePixelContentBoxSupported()
.then(function (isSupported) {
return isSupported ?
_this._initResizeObserver() :
_this._initDevicePixelRatioObservable();
});
};
// devicePixelRatio approach
DevicePixelContentBoxBinding.prototype._initDevicePixelRatioObservable = function () {
var _this = this;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
var win = canvasElementWindow(this._canvasElement);
if (win === null) {
throw new Error('No window is associated with the canvas');
}
this._devicePixelRatioObservable = (0, device_pixel_ratio_js_1.createObservable)(win);
this._devicePixelRatioObservable.subscribe(function () { return _this._invalidateBitmapSize(); });
this._invalidateBitmapSize();
};
DevicePixelContentBoxBinding.prototype._invalidateBitmapSize = function () {
var _a, _b;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
var win = canvasElementWindow(this._canvasElement);
if (win === null) {
return;
}
var ratio = (_b = (_a = this._devicePixelRatioObservable) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : win.devicePixelRatio;
var canvasRects = this._canvasElement.getClientRects();
var newSize =
// eslint-disable-next-line no-negated-condition
canvasRects[0] !== undefined ?
predictedBitmapSize(canvasRects[0], ratio) :
(0, size_js_1.size)({
width: this._canvasElementClientSize.width * ratio,
height: this._canvasElementClientSize.height * ratio,
});
this._suggestNewBitmapSize(newSize);
};
// ResizeObserver approach
DevicePixelContentBoxBinding.prototype._initResizeObserver = function () {
var _this = this;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
this._canvasElementResizeObserver = new ResizeObserver(function (entries) {
var entry = entries.find(function (entry) { return entry.target === _this._canvasElement; });
if (!entry || !entry.devicePixelContentBoxSize || !entry.devicePixelContentBoxSize[0]) {
return;
}
var entrySize = entry.devicePixelContentBoxSize[0];
var newSize = (0, size_js_1.size)({
width: entrySize.inlineSize,
height: entrySize.blockSize,
});
_this._suggestNewBitmapSize(newSize);
});
this._canvasElementResizeObserver.observe(this._canvasElement, { box: 'device-pixel-content-box' });
};
return DevicePixelContentBoxBinding;
}());
function bindTo(canvasElement, target) {
if (target.type === 'device-pixel-content-box') {
return new DevicePixelContentBoxBinding(canvasElement, target.transform, target.options);
}
throw new Error('Unsupported binding target');
}
exports.bindTo = bindTo;
function canvasElementWindow(canvasElement) {
// According to DOM Level 2 Core specification, ownerDocument should never be null for HTMLCanvasElement
// see https://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#node-ownerDoc
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return canvasElement.ownerDocument.defaultView;
}
function isDevicePixelContentBoxSupported() {
return new Promise(function (resolve) {
var ro = new ResizeObserver(function (entries) {
resolve(entries.every(function (entry) { return 'devicePixelContentBoxSize' in entry; }));
ro.disconnect();
});
ro.observe(document.body, { box: 'device-pixel-content-box' });
})
.catch(function () { return false; });
}
function predictedBitmapSize(canvasRect, ratio) {
return (0, size_js_1.size)({
width: Math.round(canvasRect.left * ratio + canvasRect.width * ratio) -
Math.round(canvasRect.left * ratio),
height: Math.round(canvasRect.top * ratio + canvasRect.height * ratio) -
Math.round(canvasRect.top * ratio),
});
}

236
frontend/node_modules/fancy-canvas/canvas-element-bitmap-size.mjs generated vendored Normal file
View File

@@ -0,0 +1,236 @@
import { equalSizes, size } from "./size.mjs";
import { createObservable as createDevicePixelRatioObservable } from "./device-pixel-ratio.mjs";
var DevicePixelContentBoxBinding = /** @class */ (function () {
function DevicePixelContentBoxBinding(canvasElement, transformBitmapSize, options) {
var _a;
this._canvasElement = null;
this._bitmapSizeChangedListeners = [];
this._suggestedBitmapSize = null;
this._suggestedBitmapSizeChangedListeners = [];
// devicePixelRatio approach
this._devicePixelRatioObservable = null;
// ResizeObserver approach
this._canvasElementResizeObserver = null;
this._canvasElement = canvasElement;
this._canvasElementClientSize = size({
width: this._canvasElement.clientWidth,
height: this._canvasElement.clientHeight,
});
this._transformBitmapSize = transformBitmapSize !== null && transformBitmapSize !== void 0 ? transformBitmapSize : (function (size) { return size; });
this._allowResizeObserver = (_a = options === null || options === void 0 ? void 0 : options.allowResizeObserver) !== null && _a !== void 0 ? _a : true;
this._chooseAndInitObserver();
// we MAY leave the constuctor without any bitmap size observation mechanics initialized
}
DevicePixelContentBoxBinding.prototype.dispose = function () {
var _a, _b;
if (this._canvasElement === null) {
throw new Error('Object is disposed');
}
(_a = this._canvasElementResizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
this._canvasElementResizeObserver = null;
(_b = this._devicePixelRatioObservable) === null || _b === void 0 ? void 0 : _b.dispose();
this._devicePixelRatioObservable = null;
this._suggestedBitmapSizeChangedListeners.length = 0;
this._bitmapSizeChangedListeners.length = 0;
this._canvasElement = null;
};
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElement", {
get: function () {
if (this._canvasElement === null) {
throw new Error('Object is disposed');
}
return this._canvasElement;
},
enumerable: false,
configurable: true
});
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElementClientSize", {
get: function () {
return this._canvasElementClientSize;
},
enumerable: false,
configurable: true
});
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "bitmapSize", {
get: function () {
return size({
width: this.canvasElement.width,
height: this.canvasElement.height,
});
},
enumerable: false,
configurable: true
});
/**
* Use this function to change canvas element client size until binding is disposed
* @param clientSize New client size for bound HTMLCanvasElement
*/
DevicePixelContentBoxBinding.prototype.resizeCanvasElement = function (clientSize) {
this._canvasElementClientSize = size(clientSize);
this.canvasElement.style.width = "".concat(this._canvasElementClientSize.width, "px");
this.canvasElement.style.height = "".concat(this._canvasElementClientSize.height, "px");
this._invalidateBitmapSize();
};
DevicePixelContentBoxBinding.prototype.subscribeBitmapSizeChanged = function (listener) {
this._bitmapSizeChangedListeners.push(listener);
};
DevicePixelContentBoxBinding.prototype.unsubscribeBitmapSizeChanged = function (listener) {
this._bitmapSizeChangedListeners = this._bitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
};
Object.defineProperty(DevicePixelContentBoxBinding.prototype, "suggestedBitmapSize", {
get: function () {
return this._suggestedBitmapSize;
},
enumerable: false,
configurable: true
});
DevicePixelContentBoxBinding.prototype.subscribeSuggestedBitmapSizeChanged = function (listener) {
this._suggestedBitmapSizeChangedListeners.push(listener);
};
DevicePixelContentBoxBinding.prototype.unsubscribeSuggestedBitmapSizeChanged = function (listener) {
this._suggestedBitmapSizeChangedListeners = this._suggestedBitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
};
DevicePixelContentBoxBinding.prototype.applySuggestedBitmapSize = function () {
if (this._suggestedBitmapSize === null) {
// nothing to apply
return;
}
var oldSuggestedSize = this._suggestedBitmapSize;
this._suggestedBitmapSize = null;
this._resizeBitmap(oldSuggestedSize);
this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, this._suggestedBitmapSize);
};
DevicePixelContentBoxBinding.prototype._resizeBitmap = function (newSize) {
var oldSize = this.bitmapSize;
if (equalSizes(oldSize, newSize)) {
return;
}
this.canvasElement.width = newSize.width;
this.canvasElement.height = newSize.height;
this._emitBitmapSizeChanged(oldSize, newSize);
};
DevicePixelContentBoxBinding.prototype._emitBitmapSizeChanged = function (oldSize, newSize) {
var _this = this;
this._bitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
};
DevicePixelContentBoxBinding.prototype._suggestNewBitmapSize = function (newSize) {
var oldSuggestedSize = this._suggestedBitmapSize;
var finalNewSize = size(this._transformBitmapSize(newSize, this._canvasElementClientSize));
var newSuggestedSize = equalSizes(this.bitmapSize, finalNewSize) ? null : finalNewSize;
if (oldSuggestedSize === null && newSuggestedSize === null) {
return;
}
if (oldSuggestedSize !== null && newSuggestedSize !== null
&& equalSizes(oldSuggestedSize, newSuggestedSize)) {
return;
}
this._suggestedBitmapSize = newSuggestedSize;
this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, newSuggestedSize);
};
DevicePixelContentBoxBinding.prototype._emitSuggestedBitmapSizeChanged = function (oldSize, newSize) {
var _this = this;
this._suggestedBitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
};
DevicePixelContentBoxBinding.prototype._chooseAndInitObserver = function () {
var _this = this;
if (!this._allowResizeObserver) {
this._initDevicePixelRatioObservable();
return;
}
isDevicePixelContentBoxSupported()
.then(function (isSupported) {
return isSupported ?
_this._initResizeObserver() :
_this._initDevicePixelRatioObservable();
});
};
// devicePixelRatio approach
DevicePixelContentBoxBinding.prototype._initDevicePixelRatioObservable = function () {
var _this = this;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
var win = canvasElementWindow(this._canvasElement);
if (win === null) {
throw new Error('No window is associated with the canvas');
}
this._devicePixelRatioObservable = createDevicePixelRatioObservable(win);
this._devicePixelRatioObservable.subscribe(function () { return _this._invalidateBitmapSize(); });
this._invalidateBitmapSize();
};
DevicePixelContentBoxBinding.prototype._invalidateBitmapSize = function () {
var _a, _b;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
var win = canvasElementWindow(this._canvasElement);
if (win === null) {
return;
}
var ratio = (_b = (_a = this._devicePixelRatioObservable) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : win.devicePixelRatio;
var canvasRects = this._canvasElement.getClientRects();
var newSize =
// eslint-disable-next-line no-negated-condition
canvasRects[0] !== undefined ?
predictedBitmapSize(canvasRects[0], ratio) :
size({
width: this._canvasElementClientSize.width * ratio,
height: this._canvasElementClientSize.height * ratio,
});
this._suggestNewBitmapSize(newSize);
};
// ResizeObserver approach
DevicePixelContentBoxBinding.prototype._initResizeObserver = function () {
var _this = this;
if (this._canvasElement === null) {
// it looks like we are already dead
return;
}
this._canvasElementResizeObserver = new ResizeObserver(function (entries) {
var entry = entries.find(function (entry) { return entry.target === _this._canvasElement; });
if (!entry || !entry.devicePixelContentBoxSize || !entry.devicePixelContentBoxSize[0]) {
return;
}
var entrySize = entry.devicePixelContentBoxSize[0];
var newSize = size({
width: entrySize.inlineSize,
height: entrySize.blockSize,
});
_this._suggestNewBitmapSize(newSize);
});
this._canvasElementResizeObserver.observe(this._canvasElement, { box: 'device-pixel-content-box' });
};
return DevicePixelContentBoxBinding;
}());
export function bindTo(canvasElement, target) {
if (target.type === 'device-pixel-content-box') {
return new DevicePixelContentBoxBinding(canvasElement, target.transform, target.options);
}
throw new Error('Unsupported binding target');
}
function canvasElementWindow(canvasElement) {
// According to DOM Level 2 Core specification, ownerDocument should never be null for HTMLCanvasElement
// see https://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#node-ownerDoc
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return canvasElement.ownerDocument.defaultView;
}
function isDevicePixelContentBoxSupported() {
return new Promise(function (resolve) {
var ro = new ResizeObserver(function (entries) {
resolve(entries.every(function (entry) { return 'devicePixelContentBoxSize' in entry; }));
ro.disconnect();
});
ro.observe(document.body, { box: 'device-pixel-content-box' });
})
.catch(function () { return false; });
}
function predictedBitmapSize(canvasRect, ratio) {
return size({
width: Math.round(canvasRect.left * ratio + canvasRect.width * ratio) -
Math.round(canvasRect.left * ratio),
height: Math.round(canvasRect.top * ratio + canvasRect.height * ratio) -
Math.round(canvasRect.top * ratio),
});
}

40
frontend/node_modules/fancy-canvas/canvas-rendering-target.d.mts generated vendored Normal file
View File

@@ -0,0 +1,40 @@
import { Size } from "./size.mjs";
import { Binding as CanvasElementBitmapSizeBinding } from "./canvas-element-bitmap-size.mjs";
/**
* @experimental
*/
export interface MediaCoordinatesRenderingScope {
readonly context: CanvasRenderingContext2D;
readonly mediaSize: Size;
}
/**
* @experimental
*/
export interface BitmapCoordinatesRenderingScope {
readonly context: CanvasRenderingContext2D;
readonly mediaSize: Size;
readonly bitmapSize: Size;
readonly horizontalPixelRatio: number;
readonly verticalPixelRatio: number;
}
/**
* @experimental
*/
export declare class CanvasRenderingTarget2D {
private readonly _context;
private readonly _mediaSize;
private readonly _bitmapSize;
constructor(context: CanvasRenderingContext2D, mediaSize: Size, bitmapSize: Size);
useMediaCoordinateSpace<T>(f: (scope: MediaCoordinatesRenderingScope) => T): T;
useBitmapCoordinateSpace<T>(f: (scope: BitmapCoordinatesRenderingScope) => T): T;
private get _horizontalPixelRatio();
private get _verticalPixelRatio();
}
/**
* @experimental
*/
export declare function createCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D;
/**
* @experimental
*/
export declare function tryCreateCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D | null;

40
frontend/node_modules/fancy-canvas/canvas-rendering-target.d.ts generated vendored Normal file
View File

@@ -0,0 +1,40 @@
import { Size } from './size.js';
import { Binding as CanvasElementBitmapSizeBinding } from './canvas-element-bitmap-size.js';
/**
* @experimental
*/
export interface MediaCoordinatesRenderingScope {
readonly context: CanvasRenderingContext2D;
readonly mediaSize: Size;
}
/**
* @experimental
*/
export interface BitmapCoordinatesRenderingScope {
readonly context: CanvasRenderingContext2D;
readonly mediaSize: Size;
readonly bitmapSize: Size;
readonly horizontalPixelRatio: number;
readonly verticalPixelRatio: number;
}
/**
* @experimental
*/
export declare class CanvasRenderingTarget2D {
private readonly _context;
private readonly _mediaSize;
private readonly _bitmapSize;
constructor(context: CanvasRenderingContext2D, mediaSize: Size, bitmapSize: Size);
useMediaCoordinateSpace<T>(f: (scope: MediaCoordinatesRenderingScope) => T): T;
useBitmapCoordinateSpace<T>(f: (scope: BitmapCoordinatesRenderingScope) => T): T;
private get _horizontalPixelRatio();
private get _verticalPixelRatio();
}
/**
* @experimental
*/
export declare function createCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D;
/**
* @experimental
*/
export declare function tryCreateCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D | null;

100
frontend/node_modules/fancy-canvas/canvas-rendering-target.js generated vendored Normal file
View File

@@ -0,0 +1,100 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.tryCreateCanvasRenderingTarget2D = exports.createCanvasRenderingTarget2D = exports.CanvasRenderingTarget2D = void 0;
/**
* @experimental
*/
var CanvasRenderingTarget2D = /** @class */ (function () {
function CanvasRenderingTarget2D(context, mediaSize, bitmapSize) {
if (mediaSize.width === 0 || mediaSize.height === 0) {
throw new TypeError('Rendering target could only be created on a media with positive width and height');
}
this._mediaSize = mediaSize;
// !Number.isInteger(bitmapSize.width) || !Number.isInteger(bitmapSize.height)
if (bitmapSize.width === 0 || bitmapSize.height === 0) {
throw new TypeError('Rendering target could only be created using a bitmap with positive integer width and height');
}
this._bitmapSize = bitmapSize;
this._context = context;
}
CanvasRenderingTarget2D.prototype.useMediaCoordinateSpace = function (f) {
try {
this._context.save();
// do not use resetTransform to support old versions of Edge
this._context.setTransform(1, 0, 0, 1, 0, 0);
this._context.scale(this._horizontalPixelRatio, this._verticalPixelRatio);
return f({
context: this._context,
mediaSize: this._mediaSize,
});
}
finally {
this._context.restore();
}
};
CanvasRenderingTarget2D.prototype.useBitmapCoordinateSpace = function (f) {
try {
this._context.save();
// do not use resetTransform to support old versions of Edge
this._context.setTransform(1, 0, 0, 1, 0, 0);
return f({
context: this._context,
mediaSize: this._mediaSize,
bitmapSize: this._bitmapSize,
horizontalPixelRatio: this._horizontalPixelRatio,
verticalPixelRatio: this._verticalPixelRatio,
});
}
finally {
this._context.restore();
}
};
Object.defineProperty(CanvasRenderingTarget2D.prototype, "_horizontalPixelRatio", {
get: function () {
return this._bitmapSize.width / this._mediaSize.width;
},
enumerable: false,
configurable: true
});
Object.defineProperty(CanvasRenderingTarget2D.prototype, "_verticalPixelRatio", {
get: function () {
return this._bitmapSize.height / this._mediaSize.height;
},
enumerable: false,
configurable: true
});
return CanvasRenderingTarget2D;
}());
exports.CanvasRenderingTarget2D = CanvasRenderingTarget2D;
/**
* @experimental
*/
function createCanvasRenderingTarget2D(binding, contextOptions) {
var mediaSize = binding.canvasElementClientSize;
var bitmapSize = binding.bitmapSize;
var context = binding.canvasElement.getContext('2d', contextOptions);
if (context === null) {
throw new Error('Could not get 2d drawing context from bound canvas element. Has the canvas already been set to a different context mode?');
}
return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
}
exports.createCanvasRenderingTarget2D = createCanvasRenderingTarget2D;
/**
* @experimental
*/
function tryCreateCanvasRenderingTarget2D(binding, contextOptions) {
var mediaSize = binding.canvasElementClientSize;
if (mediaSize.width === 0 || mediaSize.height === 0) {
return null;
}
var bitmapSize = binding.bitmapSize;
if (bitmapSize.width === 0 || bitmapSize.height === 0) {
return null;
}
var context = binding.canvasElement.getContext('2d', contextOptions);
if (context === null) {
return null;
}
return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
}
exports.tryCreateCanvasRenderingTarget2D = tryCreateCanvasRenderingTarget2D;

95
frontend/node_modules/fancy-canvas/canvas-rendering-target.mjs generated vendored Normal file
View File

@@ -0,0 +1,95 @@
/**
* @experimental
*/
var CanvasRenderingTarget2D = /** @class */ (function () {
function CanvasRenderingTarget2D(context, mediaSize, bitmapSize) {
if (mediaSize.width === 0 || mediaSize.height === 0) {
throw new TypeError('Rendering target could only be created on a media with positive width and height');
}
this._mediaSize = mediaSize;
// !Number.isInteger(bitmapSize.width) || !Number.isInteger(bitmapSize.height)
if (bitmapSize.width === 0 || bitmapSize.height === 0) {
throw new TypeError('Rendering target could only be created using a bitmap with positive integer width and height');
}
this._bitmapSize = bitmapSize;
this._context = context;
}
CanvasRenderingTarget2D.prototype.useMediaCoordinateSpace = function (f) {
try {
this._context.save();
// do not use resetTransform to support old versions of Edge
this._context.setTransform(1, 0, 0, 1, 0, 0);
this._context.scale(this._horizontalPixelRatio, this._verticalPixelRatio);
return f({
context: this._context,
mediaSize: this._mediaSize,
});
}
finally {
this._context.restore();
}
};
CanvasRenderingTarget2D.prototype.useBitmapCoordinateSpace = function (f) {
try {
this._context.save();
// do not use resetTransform to support old versions of Edge
this._context.setTransform(1, 0, 0, 1, 0, 0);
return f({
context: this._context,
mediaSize: this._mediaSize,
bitmapSize: this._bitmapSize,
horizontalPixelRatio: this._horizontalPixelRatio,
verticalPixelRatio: this._verticalPixelRatio,
});
}
finally {
this._context.restore();
}
};
Object.defineProperty(CanvasRenderingTarget2D.prototype, "_horizontalPixelRatio", {
get: function () {
return this._bitmapSize.width / this._mediaSize.width;
},
enumerable: false,
configurable: true
});
Object.defineProperty(CanvasRenderingTarget2D.prototype, "_verticalPixelRatio", {
get: function () {
return this._bitmapSize.height / this._mediaSize.height;
},
enumerable: false,
configurable: true
});
return CanvasRenderingTarget2D;
}());
export { CanvasRenderingTarget2D };
/**
* @experimental
*/
export function createCanvasRenderingTarget2D(binding, contextOptions) {
var mediaSize = binding.canvasElementClientSize;
var bitmapSize = binding.bitmapSize;
var context = binding.canvasElement.getContext('2d', contextOptions);
if (context === null) {
throw new Error('Could not get 2d drawing context from bound canvas element. Has the canvas already been set to a different context mode?');
}
return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
}
/**
* @experimental
*/
export function tryCreateCanvasRenderingTarget2D(binding, contextOptions) {
var mediaSize = binding.canvasElementClientSize;
if (mediaSize.width === 0 || mediaSize.height === 0) {
return null;
}
var bitmapSize = binding.bitmapSize;
if (bitmapSize.width === 0 || bitmapSize.height === 0) {
return null;
}
var context = binding.canvasElement.getContext('2d', contextOptions);
if (context === null) {
return null;
}
return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
}

3
frontend/node_modules/fancy-canvas/device-pixel-ratio.d.mts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import Disposable from "./disposable.mjs";
import { BehaviorSubject } from "./rx.mjs";
export declare function createObservable(win: Window): BehaviorSubject<number> & Disposable;

3
frontend/node_modules/fancy-canvas/device-pixel-ratio.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import Disposable from './disposable.js';
import { BehaviorSubject } from './rx.js';
export declare function createObservable(win: Window): BehaviorSubject<number> & Disposable;

64
frontend/node_modules/fancy-canvas/device-pixel-ratio.js generated vendored Normal file
View File

@@ -0,0 +1,64 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createObservable = void 0;
var Observable = /** @class */ (function () {
function Observable(win) {
var _this = this;
this._resolutionListener = function () { return _this._onResolutionChanged(); };
this._resolutionMediaQueryList = null;
this._observers = [];
this._window = win;
this._installResolutionListener();
}
Observable.prototype.dispose = function () {
this._uninstallResolutionListener();
this._window = null;
};
Object.defineProperty(Observable.prototype, "value", {
get: function () {
return this._window.devicePixelRatio;
},
enumerable: false,
configurable: true
});
Observable.prototype.subscribe = function (next) {
var _this = this;
var observer = { next: next };
this._observers.push(observer);
return {
unsubscribe: function () {
_this._observers = _this._observers.filter(function (o) { return o !== observer; });
},
};
};
Observable.prototype._installResolutionListener = function () {
if (this._resolutionMediaQueryList !== null) {
throw new Error('Resolution listener is already installed');
}
var dppx = this._window.devicePixelRatio;
this._resolutionMediaQueryList = this._window.matchMedia("all and (resolution: ".concat(dppx, "dppx)"));
// IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
this._resolutionMediaQueryList.addListener(this._resolutionListener);
};
Observable.prototype._uninstallResolutionListener = function () {
if (this._resolutionMediaQueryList !== null) {
// IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
this._resolutionMediaQueryList.removeListener(this._resolutionListener);
this._resolutionMediaQueryList = null;
}
};
Observable.prototype._reinstallResolutionListener = function () {
this._uninstallResolutionListener();
this._installResolutionListener();
};
Observable.prototype._onResolutionChanged = function () {
var _this = this;
this._observers.forEach(function (observer) { return observer.next(_this._window.devicePixelRatio); });
this._reinstallResolutionListener();
};
return Observable;
}());
function createObservable(win) {
return new Observable(win);
}
exports.createObservable = createObservable;

60
frontend/node_modules/fancy-canvas/device-pixel-ratio.mjs generated vendored Normal file
View File

@@ -0,0 +1,60 @@
var Observable = /** @class */ (function () {
function Observable(win) {
var _this = this;
this._resolutionListener = function () { return _this._onResolutionChanged(); };
this._resolutionMediaQueryList = null;
this._observers = [];
this._window = win;
this._installResolutionListener();
}
Observable.prototype.dispose = function () {
this._uninstallResolutionListener();
this._window = null;
};
Object.defineProperty(Observable.prototype, "value", {
get: function () {
return this._window.devicePixelRatio;
},
enumerable: false,
configurable: true
});
Observable.prototype.subscribe = function (next) {
var _this = this;
var observer = { next: next };
this._observers.push(observer);
return {
unsubscribe: function () {
_this._observers = _this._observers.filter(function (o) { return o !== observer; });
},
};
};
Observable.prototype._installResolutionListener = function () {
if (this._resolutionMediaQueryList !== null) {
throw new Error('Resolution listener is already installed');
}
var dppx = this._window.devicePixelRatio;
this._resolutionMediaQueryList = this._window.matchMedia("all and (resolution: ".concat(dppx, "dppx)"));
// IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
this._resolutionMediaQueryList.addListener(this._resolutionListener);
};
Observable.prototype._uninstallResolutionListener = function () {
if (this._resolutionMediaQueryList !== null) {
// IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
this._resolutionMediaQueryList.removeListener(this._resolutionListener);
this._resolutionMediaQueryList = null;
}
};
Observable.prototype._reinstallResolutionListener = function () {
this._uninstallResolutionListener();
this._installResolutionListener();
};
Observable.prototype._onResolutionChanged = function () {
var _this = this;
this._observers.forEach(function (observer) { return observer.next(_this._window.devicePixelRatio); });
this._reinstallResolutionListener();
};
return Observable;
}());
export function createObservable(win) {
return new Observable(win);
}

3
frontend/node_modules/fancy-canvas/disposable.d.mts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
export default interface Disposable {
dispose(): void;
}

3
frontend/node_modules/fancy-canvas/disposable.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
export default interface Disposable {
dispose(): void;
}

2
frontend/node_modules/fancy-canvas/disposable.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

1
frontend/node_modules/fancy-canvas/disposable.mjs generated vendored Normal file
View File

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

4
frontend/node_modules/fancy-canvas/index.d.mts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
export { default as Disposable } from "./disposable.mjs";
export { Size, size, equalSizes } from "./size.mjs";
export { Binding as CanvasElementBitmapSizeBinding, BindingTarget as CanvasElementBitmapSizeBindingTarget, BitmapSizeChangedListener, bindTo as bindCanvasElementBitmapSizeTo, } from "./canvas-element-bitmap-size.mjs";
export { CanvasRenderingTarget2D, MediaCoordinatesRenderingScope, BitmapCoordinatesRenderingScope, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from "./canvas-rendering-target.mjs";

4
frontend/node_modules/fancy-canvas/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
export { default as Disposable } from './disposable.js';
export { Size, size, equalSizes } from './size.js';
export { Binding as CanvasElementBitmapSizeBinding, BindingTarget as CanvasElementBitmapSizeBindingTarget, BitmapSizeChangedListener, bindTo as bindCanvasElementBitmapSizeTo, } from './canvas-element-bitmap-size.js';
export { CanvasRenderingTarget2D, MediaCoordinatesRenderingScope, BitmapCoordinatesRenderingScope, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from './canvas-rendering-target.js';

12
frontend/node_modules/fancy-canvas/index.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.tryCreateCanvasRenderingTarget2D = exports.createCanvasRenderingTarget2D = exports.CanvasRenderingTarget2D = exports.bindCanvasElementBitmapSizeTo = exports.equalSizes = exports.size = void 0;
var size_js_1 = require("./size.js");
Object.defineProperty(exports, "size", { enumerable: true, get: function () { return size_js_1.size; } });
Object.defineProperty(exports, "equalSizes", { enumerable: true, get: function () { return size_js_1.equalSizes; } });
var canvas_element_bitmap_size_js_1 = require("./canvas-element-bitmap-size.js");
Object.defineProperty(exports, "bindCanvasElementBitmapSizeTo", { enumerable: true, get: function () { return canvas_element_bitmap_size_js_1.bindTo; } });
var canvas_rendering_target_js_1 = require("./canvas-rendering-target.js");
Object.defineProperty(exports, "CanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.CanvasRenderingTarget2D; } });
Object.defineProperty(exports, "createCanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.createCanvasRenderingTarget2D; } });
Object.defineProperty(exports, "tryCreateCanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.tryCreateCanvasRenderingTarget2D; } });

3
frontend/node_modules/fancy-canvas/index.mjs generated vendored Normal file
View File

@@ -0,0 +1,3 @@
export { size, equalSizes } from "./size.mjs";
export { bindTo as bindCanvasElementBitmapSizeTo, } from "./canvas-element-bitmap-size.mjs";
export { CanvasRenderingTarget2D, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from "./canvas-rendering-target.mjs";

26
frontend/node_modules/fancy-canvas/package.json generated vendored Normal file
View File

@@ -0,0 +1,26 @@
{
"name": "fancy-canvas",
"version": "2.1.0",
"author": "smakarov@tradingview.com",
"description": "Functionality on top of HTML canvas element, including support for HiDPI and pixel-perfect rendering",
"keywords": [
"html",
"canvas",
"graphics",
"hidpi",
"pixel-perfect"
],
"license": "MIT",
"exports": {
"import": "./index.mjs",
"require": "./index.js"
},
"module": "./index.mjs",
"type": "commonjs",
"files": [
"**/*.mjs",
"**/*.d.mts",
"**/*.js",
"**/*.d.ts"
]
}

12
frontend/node_modules/fancy-canvas/rx.d.mts generated vendored Normal file
View File

@@ -0,0 +1,12 @@
export interface NextObserver<T> {
next: (value: T) => void;
}
export interface Unsubscribable {
unsubscribe(): void;
}
export interface Subscribable<T> {
subscribe(next: (value: T) => void): Unsubscribable;
}
export interface BehaviorSubject<T> extends Subscribable<T> {
readonly value: T;
}

12
frontend/node_modules/fancy-canvas/rx.d.ts generated vendored Normal file
View File

@@ -0,0 +1,12 @@
export interface NextObserver<T> {
next: (value: T) => void;
}
export interface Unsubscribable {
unsubscribe(): void;
}
export interface Subscribable<T> {
subscribe(next: (value: T) => void): Unsubscribable;
}
export interface BehaviorSubject<T> extends Subscribable<T> {
readonly value: T;
}

2
frontend/node_modules/fancy-canvas/rx.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

1
frontend/node_modules/fancy-canvas/rx.mjs generated vendored Normal file
View File

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

17
frontend/node_modules/fancy-canvas/size.d.mts generated vendored Normal file
View File

@@ -0,0 +1,17 @@
export declare type Size = Readonly<{
width: number;
height: number;
}> & {
__brand: 'Size';
};
export declare function size({ width, height }: {
width: number;
height: number;
}): Size;
export declare function equalSizes(first: {
width: number;
height: number;
}, second: {
width: number;
height: number;
}): boolean;

17
frontend/node_modules/fancy-canvas/size.d.ts generated vendored Normal file
View File

@@ -0,0 +1,17 @@
export declare type Size = Readonly<{
width: number;
height: number;
}> & {
__brand: 'Size';
};
export declare function size({ width, height }: {
width: number;
height: number;
}): Size;
export declare function equalSizes(first: {
width: number;
height: number;
}, second: {
width: number;
height: number;
}): boolean;

22
frontend/node_modules/fancy-canvas/size.js generated vendored Normal file
View File

@@ -0,0 +1,22 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.equalSizes = exports.size = void 0;
function size(_a) {
var width = _a.width, height = _a.height;
if (width < 0) {
throw new Error('Negative width is not allowed for Size');
}
if (height < 0) {
throw new Error('Negative height is not allowed for Size');
}
return {
width: width,
height: height,
};
}
exports.size = size;
function equalSizes(first, second) {
return (first.width === second.width) &&
(first.height === second.height);
}
exports.equalSizes = equalSizes;

17
frontend/node_modules/fancy-canvas/size.mjs generated vendored Normal file
View File

@@ -0,0 +1,17 @@
export function size(_a) {
var width = _a.width, height = _a.height;
if (width < 0) {
throw new Error('Negative width is not allowed for Size');
}
if (height < 0) {
throw new Error('Negative height is not allowed for Size');
}
return {
width: width,
height: height,
};
}
export function equalSizes(first, second) {
return (first.width === second.width) &&
(first.height === second.height);
}