@ntlab/ntjs-assets 2.41.0 → 2.43.0

package/assets/js/highcharts/esm/indicators/acceleration-bands.src.js

@@ -0,0 +1,578 @@
+/**
+ * @license Highstock JS v12.2.0 (2025-04-07)
+ * @module highcharts/indicators/acceleration-bands
+ * @requires highcharts
+ * @requires highcharts/modules/stock
+ *
+ * Indicator series type for Highcharts Stock
+ *
+ * (c) 2010-2025 Daniel Studencki
+ *
+ * License: www.highcharts.com/license
+ */
+import * as __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__ from "../highcharts.src.js";
+import * as __WEBPACK_EXTERNAL_MODULE__modules_stock_src_js_b3d80146__ from "../modules/stock.src.js";
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = (module) => {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			() => (module['default']) :
+/******/ 			() => (module);
+/******/ 		__webpack_require__.d(getter, { a: getter });
+/******/ 		return getter;
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+
+;// external ["../highcharts.src.js","default"]
+const external_highcharts_src_js_default_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__["default"];
+var external_highcharts_src_js_default_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_namespaceObject);
+;// external "../modules/stock.src.js"
+var x = (y) => {
+	var x = {}; __webpack_require__.d(x,
+    	y); return x
+    } 
+    var y = (x) => (() => (x))
+    const stock_src_js_namespaceObject = x({  });
+;// external ["../highcharts.src.js","default","SeriesRegistry"]
+const external_highcharts_src_js_default_SeriesRegistry_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_8202131d__["default"].SeriesRegistry;
+var external_highcharts_src_js_default_SeriesRegistry_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_SeriesRegistry_namespaceObject);
+;// ./code/es-modules/Stock/Indicators/MultipleLinesComposition.js
+/**
+ *
+ *  (c) 2010-2025 Wojciech Chmiel
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+
+
+const { sma: { prototype: smaProto } } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+const { defined, error, merge } = (external_highcharts_src_js_default_default());
+/* *
+ *
+ *  Composition
+ *
+ * */
+var MultipleLinesComposition;
+(function (MultipleLinesComposition) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    /**
+     * Additional lines DOCS names. Elements of linesApiNames array should
+     * be consistent with DOCS line names defined in your implementation.
+     * Notice that linesApiNames should have decreased amount of elements
+     * relative to pointArrayMap (without pointValKey).
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const linesApiNames = ['bottomLine'];
+    /**
+     * Lines ids. Required to plot appropriate amount of lines.
+     * Notice that pointArrayMap should have more elements than
+     * linesApiNames, because it contains main line and additional lines ids.
+     * Also it should be consistent with amount of lines calculated in
+     * getValues method from your implementation.
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const pointArrayMap = ['top', 'bottom'];
+    /**
+     * Names of the lines, between which the area should be plotted.
+     * If the drawing of the area should
+     * be disabled for some indicators, leave this option as an empty array.
+     * Names should be the same as the names in the pointArrayMap.
+     *
+     * @private
+     * @type {Array<string>}
+     */
+    const areaLinesNames = ['top'];
+    /**
+     * Main line id.
+     *
+     * @private
+     * @type {string}
+     */
+    const pointValKey = 'top';
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Composition useful for all indicators that have more than one line.
+     * Compose it with your implementation where you will provide the
+     * `getValues` method appropriate to your indicator and `pointArrayMap`,
+     * `pointValKey`, `linesApiNames` properties. Notice that `pointArrayMap`
+     * should be consistent with the amount of lines calculated in the
+     * `getValues` method.
+     *
+     * @private
+     */
+    function compose(IndicatorClass) {
+        const proto = IndicatorClass.prototype;
+        proto.linesApiNames = (proto.linesApiNames ||
+            linesApiNames.slice());
+        proto.pointArrayMap = (proto.pointArrayMap ||
+            pointArrayMap.slice());
+        proto.pointValKey = (proto.pointValKey ||
+            pointValKey);
+        proto.areaLinesNames = (proto.areaLinesNames ||
+            areaLinesNames.slice());
+        proto.drawGraph = indicatorDrawGraph;
+        proto.getGraphPath = indicatorGetGraphPath;
+        proto.toYData = indicatorToYData;
+        proto.translate = indicatorTranslate;
+        return IndicatorClass;
+    }
+    MultipleLinesComposition.compose = compose;
+    /**
+     * Generate the API name of the line
+     *
+     * @private
+     * @param propertyName name of the line
+     */
+    function getLineName(propertyName) {
+        return ('plot' +
+            propertyName.charAt(0).toUpperCase() +
+            propertyName.slice(1));
+    }
+    /**
+     * Create translatedLines Collection based on pointArrayMap.
+     *
+     * @private
+     * @param {string} [excludedValue]
+     *        Main line id
+     * @return {Array<string>}
+     *         Returns translated lines names without excluded value.
+     */
+    function getTranslatedLinesNames(indicator, excludedValue) {
+        const translatedLines = [];
+        (indicator.pointArrayMap || []).forEach((propertyName) => {
+            if (propertyName !== excludedValue) {
+                translatedLines.push(getLineName(propertyName));
+            }
+        });
+        return translatedLines;
+    }
+    /**
+     * Draw main and additional lines.
+     *
+     * @private
+     */
+    function indicatorDrawGraph() {
+        const indicator = this, pointValKey = indicator.pointValKey, linesApiNames = indicator.linesApiNames, areaLinesNames = indicator.areaLinesNames, mainLinePoints = indicator.points, mainLineOptions = indicator.options, mainLinePath = indicator.graph, gappedExtend = {
+            options: {
+                gapSize: mainLineOptions.gapSize
+            }
+        }, 
+        // Additional lines point place holders:
+        secondaryLines = [], secondaryLinesNames = getTranslatedLinesNames(indicator, pointValKey);
+        let pointsLength = mainLinePoints.length, point;
+        // Generate points for additional lines:
+        secondaryLinesNames.forEach((plotLine, index) => {
+            // Create additional lines point place holders
+            secondaryLines[index] = [];
+            while (pointsLength--) {
+                point = mainLinePoints[pointsLength];
+                secondaryLines[index].push({
+                    x: point.x,
+                    plotX: point.plotX,
+                    plotY: point[plotLine],
+                    isNull: !defined(point[plotLine])
+                });
+            }
+            pointsLength = mainLinePoints.length;
+        });
+        // Modify options and generate area fill:
+        if (indicator.userOptions.fillColor && areaLinesNames.length) {
+            const index = secondaryLinesNames.indexOf(getLineName(areaLinesNames[0])), secondLinePoints = secondaryLines[index], firstLinePoints = areaLinesNames.length === 1 ?
+                mainLinePoints :
+                secondaryLines[secondaryLinesNames.indexOf(getLineName(areaLinesNames[1]))], originalColor = indicator.color;
+            indicator.points = firstLinePoints;
+            indicator.nextPoints = secondLinePoints;
+            indicator.color = indicator.userOptions.fillColor;
+            indicator.options = merge(mainLinePoints, gappedExtend);
+            indicator.graph = indicator.area;
+            indicator.fillGraph = true;
+            smaProto.drawGraph.call(indicator);
+            indicator.area = indicator.graph;
+            // Clean temporary properties:
+            delete indicator.nextPoints;
+            delete indicator.fillGraph;
+            indicator.color = originalColor;
+        }
+        // Modify options and generate additional lines:
+        linesApiNames.forEach((lineName, i) => {
+            if (secondaryLines[i]) {
+                indicator.points = secondaryLines[i];
+                if (mainLineOptions[lineName]) {
+                    indicator.options = merge(mainLineOptions[lineName].styles, gappedExtend);
+                }
+                else {
+                    error('Error: "There is no ' + lineName +
+                        ' in DOCS options declared. Check if linesApiNames' +
+                        ' are consistent with your DOCS line names."');
+                }
+                indicator.graph = indicator['graph' + lineName];
+                smaProto.drawGraph.call(indicator);
+                // Now save lines:
+                indicator['graph' + lineName] = indicator.graph;
+            }
+            else {
+                error('Error: "' + lineName + ' doesn\'t have equivalent ' +
+                    'in pointArrayMap. To many elements in linesApiNames ' +
+                    'relative to pointArrayMap."');
+            }
+        });
+        // Restore options and draw a main line:
+        indicator.points = mainLinePoints;
+        indicator.options = mainLineOptions;
+        indicator.graph = mainLinePath;
+        smaProto.drawGraph.call(indicator);
+    }
+    /**
+     * Create the path based on points provided as argument.
+     * If indicator.nextPoints option is defined, create the areaFill.
+     *
+     * @private
+     * @param points Points on which the path should be created
+     */
+    function indicatorGetGraphPath(points) {
+        let areaPath, path = [], higherAreaPath = [];
+        points = points || this.points;
+        // Render Span
+        if (this.fillGraph && this.nextPoints) {
+            areaPath = smaProto.getGraphPath.call(this, this.nextPoints);
+            if (areaPath && areaPath.length) {
+                areaPath[0][0] = 'L';
+                path = smaProto.getGraphPath.call(this, points);
+                higherAreaPath = areaPath.slice(0, path.length);
+                // Reverse points, so that the areaFill will start from the end:
+                for (let i = higherAreaPath.length - 1; i >= 0; i--) {
+                    path.push(higherAreaPath[i]);
+                }
+            }
+        }
+        else {
+            path = smaProto.getGraphPath.apply(this, arguments);
+        }
+        return path;
+    }
+    /**
+     * @private
+     * @param {Highcharts.Point} point
+     *        Indicator point
+     * @return {Array<number>}
+     *         Returns point Y value for all lines
+     */
+    function indicatorToYData(point) {
+        const pointColl = [];
+        (this.pointArrayMap || []).forEach((propertyName) => {
+            pointColl.push(point[propertyName]);
+        });
+        return pointColl;
+    }
+    /**
+     * Add lines plot pixel values.
+     *
+     * @private
+     */
+    function indicatorTranslate() {
+        const pointArrayMap = this.pointArrayMap;
+        let LinesNames = [], value;
+        LinesNames = getTranslatedLinesNames(this);
+        smaProto.translate.apply(this, arguments);
+        this.points.forEach((point) => {
+            pointArrayMap.forEach((propertyName, i) => {
+                value = point[propertyName];
+                // If the modifier, like for example compare exists,
+                // modified the original value by that method, #15867.
+                if (this.dataModify) {
+                    value = this.dataModify.modifyValue(value);
+                }
+                if (value !== null) {
+                    point[LinesNames[i]] = this.yAxis.toPixels(value, true);
+                }
+            });
+        });
+    }
+})(MultipleLinesComposition || (MultipleLinesComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Indicators_MultipleLinesComposition = (MultipleLinesComposition);
+
+;// ./code/es-modules/Stock/Indicators/ABands/ABandsIndicator.js
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+
+
+
+const { sma: SMAIndicator } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+const { correctFloat, extend, merge: ABandsIndicator_merge } = (external_highcharts_src_js_default_default());
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function getBaseForBand(low, high, factor) {
+    return (((correctFloat(high - low)) /
+        ((correctFloat(high + low)) / 2)) * 1000) * factor;
+}
+/**
+ * @private
+ */
+function getPointUB(high, base) {
+    return high * (correctFloat(1 + 2 * base));
+}
+/**
+ * @private
+ */
+function getPointLB(low, base) {
+    return low * (correctFloat(1 - 2 * base));
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * The ABands series type
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.abands
+ *
+ * @augments Highcharts.Series
+ */
+class ABandsIndicator extends SMAIndicator {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    getValues(series, params) {
+        const period = params.period, factor = params.factor, index = params.index, xVal = series.xData, yVal = series.yData, yValLen = yVal ? yVal.length : 0, 
+        // Upperbands
+        UB = [], 
+        // Lowerbands
+        LB = [], 
+        // ABANDS array structure:
+        // 0-date, 1-top line, 2-middle line, 3-bottom line
+        ABANDS = [], low = 2, high = 1, xData = [], yData = [];
+        // Middle line, top line and bottom line
+        let ML, TL, BL, date, bandBase, pointSMA, ubSMA, lbSMA, slicedX, slicedY, i;
+        if (yValLen < period) {
+            return;
+        }
+        for (i = 0; i <= yValLen; i++) {
+            // Get UB and LB values of every point. This condition
+            // is necessary, because there is a need to calculate current
+            // UB nad LB values simultaneously with given period SMA
+            // in one for loop.
+            if (i < yValLen) {
+                bandBase = getBaseForBand(yVal[i][low], yVal[i][high], factor);
+                UB.push(getPointUB(yVal[i][high], bandBase));
+                LB.push(getPointLB(yVal[i][low], bandBase));
+            }
+            if (i >= period) {
+                slicedX = xVal.slice(i - period, i);
+                slicedY = yVal.slice(i - period, i);
+                ubSMA = super.getValues.call(this, {
+                    xData: slicedX,
+                    yData: UB.slice(i - period, i)
+                }, {
+                    period: period
+                });
+                lbSMA = super.getValues.call(this, {
+                    xData: slicedX,
+                    yData: LB.slice(i - period, i)
+                }, {
+                    period: period
+                });
+                pointSMA = super.getValues.call(this, {
+                    xData: slicedX,
+                    yData: slicedY
+                }, {
+                    period: period,
+                    index: index
+                });
+                date = pointSMA.xData[0];
+                TL = ubSMA.yData[0];
+                BL = lbSMA.yData[0];
+                ML = pointSMA.yData[0];
+                ABANDS.push([date, TL, ML, BL]);
+                xData.push(date);
+                yData.push([TL, ML, BL]);
+            }
+        }
+        return {
+            values: ABANDS,
+            xData: xData,
+            yData: yData
+        };
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+/**
+ * Acceleration bands (ABANDS). This series requires the `linkedTo` option
+ * to be set and should be loaded after the
+ * `stock/indicators/indicators.js`.
+ *
+ * @sample {highstock} stock/indicators/acceleration-bands
+ *         Acceleration Bands
+ *
+ * @extends      plotOptions.sma
+ * @mixes        Highcharts.MultipleLinesMixin
+ * @since        7.0.0
+ * @product      highstock
+ * @excluding    allAreas, colorAxis, compare, compareBase, joinBy, keys,
+ *               navigatorOptions, pointInterval, pointIntervalUnit,
+ *               pointPlacement, pointRange, pointStart, showInNavigator,
+ *               stacking,
+ * @requires     stock/indicators/indicators
+ * @requires     stock/indicators/acceleration-bands
+ * @optionparent plotOptions.abands
+ */
+ABandsIndicator.defaultOptions = ABandsIndicator_merge(SMAIndicator.defaultOptions, {
+    /**
+     * Option for fill color between lines in Accelleration bands Indicator.
+     *
+     * @sample {highstock} stock/indicators/indicator-area-fill
+     *      Background fill between lines.
+     *
+     * @type {Highcharts.Color}
+     * @since 9.3.2
+     * @apioption plotOptions.abands.fillColor
+     *
+     */
+    params: {
+        period: 20,
+        /**
+         * The algorithms factor value used to calculate bands.
+         *
+         * @product highstock
+         */
+        factor: 0.001,
+        index: 3
+    },
+    lineWidth: 1,
+    topLine: {
+        styles: {
+            /**
+             * Pixel width of the line.
+             */
+            lineWidth: 1
+        }
+    },
+    bottomLine: {
+        styles: {
+            /**
+             * Pixel width of the line.
+             */
+            lineWidth: 1
+        }
+    },
+    dataGrouping: {
+        approximation: 'averages'
+    }
+});
+extend(ABandsIndicator.prototype, {
+    areaLinesNames: ['top', 'bottom'],
+    linesApiNames: ['topLine', 'bottomLine'],
+    nameBase: 'Acceleration Bands',
+    nameComponents: ['period', 'factor'],
+    pointArrayMap: ['top', 'middle', 'bottom'],
+    pointValKey: 'middle'
+});
+Indicators_MultipleLinesComposition.compose(ABandsIndicator);
+external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('abands', ABandsIndicator);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const ABands_ABandsIndicator = ((/* unused pure expression or super */ null && (ABandsIndicator)));
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * An Acceleration bands indicator. If the [type](#series.abands.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.abands
+ * @since     7.0.0
+ * @product   highstock
+ * @excluding allAreas, colorAxis, compare, compareBase, dataParser, dataURL,
+ *            joinBy, keys, navigatorOptions, pointInterval,
+ *            pointIntervalUnit, pointPlacement, pointRange, pointStart,
+ *            stacking, showInNavigator,
+ * @requires  stock/indicators/indicators
+ * @requires  stock/indicators/acceleration-bands
+ * @apioption series.abands
+ */
+''; // To include the above in jsdoc
+
+;// ./code/es-modules/masters/indicators/acceleration-bands.src.js
+
+
+
+
+
+/* harmony default export */ const acceleration_bands_src = ((external_highcharts_src_js_default_default()));
+
+export { acceleration_bands_src as default };

package/assets/js/highcharts/esm/indicators/accumulation-distribution.js

@@ -0,0 +1 @@
+import*as e from"../highcharts.js";import"../modules/stock.js";var t={};t.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return t.d(r,{a:r}),r},t.d=(e,r)=>{for(var a in r)t.o(r,a)&&!t.o(e,a)&&Object.defineProperty(e,a,{enumerable:!0,get:r[a]})},t.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t);let r=e.default;var a=t.n(r);t.d({},{});let s=e.default.SeriesRegistry;var o=t.n(s);let{sma:l}=o().seriesTypes,{error:u,extend:i,merge:n}=a();class p extends l{static populateAverage(e,t,r,a,s){let o=t[a][1],l=t[a][2],u=t[a][3],i=r[a],n=u===o&&u===l||o===l?0:(2*u-l-o)/(o-l)*i;return[e[a],n]}getValues(e,t){let r,a,s,o=t.period,l=e.xData,i=e.yData,n=t.volumeSeriesID,d=e.chart.get(n),c=d?.getColumn("y"),m=i?i.length:0,h=[],f=[],g=[];if(!(l.length<=o)||!m||4===i[0].length){if(!d){u("Series "+n+" not found! Check `volumeSeriesID`.",!0,e.chart);return}for(a=o;a<m;a++)r=h.length,s=p.populateAverage(l,i,c,a,o),r>0&&(s[1]+=h[r-1][1]),h.push(s),f.push(s[0]),g.push(s[1]);return{values:h,xData:f,yData:g}}}}p.defaultOptions=n(l.defaultOptions,{params:{index:void 0,volumeSeriesID:"volume"}}),i(p.prototype,{nameComponents:!1,nameBase:"Accumulation/Distribution"}),o().registerSeriesType("ad",p);let d=a();export{d as default};