svelteplot 0.10.3-pr-477.2 → 0.10.3-pr-477.3

package/dist/helpers/autoScales.d.ts

@@ -1,5 +1,5 @@
 import type { ColorScaleOptions, PlotDefaults, PlotOptions, RawValue, ScaleName, ScaleOptions, ScaleType } from '../types/index.js';
-export declare function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }: {
+export declare function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults: _plotDefaults }: {
     name: ScaleName;
     type: ScaleType;
     domain: RawValue[];
@@ -10,7 +10,7 @@ export declare function autoScale({ name, type, domain, scaleOptions, plotOption
     plotHasFilledDotMarks: boolean;
     plotDefaults: PlotDefaults;
 }): any;
-export declare function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }: {
+export declare function autoScaleColor({ type, domain, scaleOptions, plotOptions: _plotOptions, plotWidth: _plotWidth, plotHeight: _plotHeight, plotHasFilledDotMarks: _plotHasFilledDotMarks, plotDefaults }: {
     name: ScaleName;
     type: ScaleType;
     domain: RawValue[];

package/dist/helpers/autoScales.js

@@ -41,7 +41,7 @@ const ThresholdScales = {
     quantize: scaleQuantize,
     quantile: scaleQuantile
 };
-export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }) {
+export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults: _plotDefaults }) {
     let fn;
     let range;
     range =
@@ -110,7 +110,7 @@ export function autoScale({ name, type, domain, scaleOptions, plotOptions, plotW
     }
     return fn;
 }
-export function autoScaleColor({ type, domain, scaleOptions, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults }) {
+export function autoScaleColor({ type, domain, scaleOptions, plotOptions: _plotOptions, plotWidth: _plotWidth, plotHeight: _plotHeight, plotHasFilledDotMarks: _plotHasFilledDotMarks, plotDefaults }) {
     let fn;
     let range;
     // special treatment for color scales

package/dist/helpers/resolve.js

@@ -93,7 +93,6 @@ const scaledStyleProps = {
     strokeOpacity: 'stroke-opacity',
     opacity: 'opacity'
 };
-const scaledStylePropsKeys = Object.keys(scaledStyleProps);
 // TODO: find a better name
 const oppositeColor = {
     fill: 'stroke',

package/dist/transforms/bin.js

@@ -103,7 +103,7 @@ export function binY({ data, ...channels }, options = { thresholds: 'auto', cumu
  * for binning in x and y dimension simultaneously
  */
 export function bin({ data, ...channels }, options = { thresholds: 'auto', cumulative: false }) {
-    const { domain, thresholds = 'auto', interval, cumulative = false } = options;
+    const { domain, thresholds = 'auto', interval } = options;
     const binX = d3Bin();
     const binY = d3Bin();
     if (domain) {
@@ -169,7 +169,7 @@ export function bin({ data, ...channels }, options = { thresholds: 'auto', cumul
         const [ylo, yhi] = extent(groupX.map((d) => resolveChannel('y', d, channels)));
         const tExtentLo = yThresholds.filter((d) => d < ylo).at(-1) ?? ylo;
         const tExtentHi = yThresholds.filter((d) => d > yhi).at(0) ?? yhi;
-        binY(groupX).forEach((groupY, i) => {
+        binY(groupX).forEach((groupY) => {
             if (groupY.length === 0)
                 return;
             // The first bin.x0 is always equal to the minimum domain value,

package/dist/transforms/bollinger.js

@@ -46,7 +46,7 @@ function bollinger(values, N, K) {
         const value = values[i];
         ((sum += value), (sumSquared += value ** 2));
     }
-    for (let n = values.length, m = bands.length; i < n; ++i) {
+    for (let n = values.length; i < n; ++i) {
         const value = values[i];
         ((sum += value), (sumSquared += value ** 2));
         const mean = sum / N;

package/dist/transforms/density.d.ts

@@ -4,7 +4,7 @@
 import type { TransformArg } from '../types';
 export type KernelName = 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine';
 export type Kernel = KernelName | ((u: number) => number);
-export type DensityOptions<T> = {
+export type DensityOptions<_T> = {
     /**
      * The kernel function to use for smoothing.
      */

package/dist/transforms/density.js

@@ -156,9 +156,9 @@ function density1d(independent, { data, weight, ...channels }, options = {}) {
             .sort((a, b) => a[0] - b[0]);
         if (!trim) {
             // trim zero values at begin and end except first and last
-            const firstNonZero = kdeValues.findIndex(([x, v]) => v > 0);
+            const firstNonZero = kdeValues.findIndex(([_x, v]) => v > 0);
             // if (firstNonZero > 0) minX = Math.min(minX, kdeValues[firstNonZero - 1][0]);
-            const lastNonZero = kdeValues.length - 1 - [...kdeValues].reverse().findIndex(([x, v]) => v > 0);
+            const lastNonZero = kdeValues.length - 1 - [...kdeValues].reverse().findIndex(([_x, v]) => v > 0);
             // if (lastNonZero > -1 && lastNonZero < kdeValues.length - 1)
             //     maxX = Math.max(maxX, kdeValues[lastNonZero + 1][0]);
             kdeValues = kdeValues.slice(firstNonZero < 1 ? 0 : firstNonZero - 1, lastNonZero < 0 ? kdeValues.length : lastNonZero + 1);

package/dist/transforms/dodge.js

@@ -126,7 +126,7 @@ function anchorYTop({ options: { marginTop } }) {
 function anchorYBottom({ facetHeight: height }) {
     return [-1, height];
 }
-function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom } }) {
+function anchorYMiddle({ facetHeight: height, options: { marginTop, marginBottom: _marginBottom } }) {
     return [0, (marginTop + height) / 2];
 }
 function compareSymmetric(a, b) {

package/dist/transforms/jitter.js

@@ -77,7 +77,7 @@ function parseNumber(value) {
             const [name, period] = parseTimeInterval(value);
             return (durations.get(name) ?? 0) * period;
         }
-        catch (err) {
+        catch {
             return 0;
         }
     }

package/dist/transforms/recordize.js

@@ -15,7 +15,7 @@ export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: t
     if (dataIsRawValueArray) {
         // we remove x, x1 and x2 from the channels since they make no sense when
         // the data is a raw value array
-        const { x, x1, x2, ...nonXChannels } = channels;
+        const { x: _x, x1: _x1, x2: _x2, ...nonXChannels } = channels;
         return {
             data: data.map((value, index) => ({
                 [RAW_VALUE]: value,
@@ -39,7 +39,7 @@ export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: t
     if (dataIsRawValueArray) {
         // we remove y, y1 and y2 from the channels since they make no sense when
         // the data is a raw value array
-        const { y, y1, y2, ...nonYChannels } = channels;
+        const { y: _y, y1: _y1, y2: _y2, ...nonYChannels } = channels;
         return {
             data: Array.from(data).map((value, index) => ({
                 [INDEX]: index,

package/dist/transforms/stack.js

@@ -55,7 +55,7 @@ function stackXY(byDim, data, channels, options) {
         channels[`${byLow}`] === undefined &&
         channels[`${byHigh}`] === undefined) {
         // resolve all channels for easier computation below
-        const resolvedData = indexData(data).map((d, i) => ({
+        const resolvedData = indexData(data).map((d) => ({
             ...(isDataRecord(d) ? d : { [RAW_VALUE]: d }),
             [S[secondDim]]: resolveChannel(secondDim, d, channels),
             [GROUP]: groupBy === true ? 'G' : resolveChannel(groupBy, d, channels),
@@ -91,7 +91,7 @@ function stackXY(byDim, data, channels, options) {
                 // Unit stacking: map each secondary-dimension bucket to an array of values.
                 // Series are positional (0..N-1) within each bucket.
                 let maxKeys = 0;
-                stackData = groupedBySecondDim.map(([k, items]) => {
+                stackData = groupedBySecondDim.map(([_k, items]) => {
                     const values = items
                         // keep original order within bucket; no stable series identity across buckets
                         .map((d) => ({ i: d[INDEX], v: d[S[byDim]] }));
@@ -104,7 +104,7 @@ function stackXY(byDim, data, channels, options) {
             else {
                 // Grouped stacking: keep consistent series identities using the group key
                 const keySet = new Set(facetData.map((d) => d[GROUP]));
-                stackData = groupedBySecondDim.map(([k, items]) => {
+                stackData = groupedBySecondDim.map(([_k, items]) => {
                     const obj = {};
                     items.forEach((d) => {
                         const key = d[GROUP];
@@ -134,7 +134,7 @@ function stackXY(byDim, data, channels, options) {
                 ? STACK_OFFSET['center']
                 : STACK_OFFSET[options.offset ?? 'none']))
                 .keys(keys)
-                .value((d, key, i, data) => {
+                .value((d, key, _i, _data) => {
                 return d[key]?.v == null ? undefined : d[key]?.v;
             })(stackData);
             // and combine it all back into a flat array
@@ -205,7 +205,7 @@ function stackMosaic({ data, x, y, value, fx, fy, ...rest }, { outer, inner }, {
         const innerOpt = inner === 'x' ? xOpt : yOpt;
         const grouped = d3Groups(data, (d) => resolveProp(d[outerChannel], d));
         const innerOrder = new Map(grouped[0][1].map((d, i) => [d[innerChannel], i]));
-        grouped.forEach(([k, items], i) => {
+        grouped.forEach(([_k, items], i) => {
             const groupValue = sum(items, (d) => resolveProp(d[value], d));
             const o1 = outerPos, o2 = outerPos + groupValue;
             outerPos = o2;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "svelteplot",
-    "version": "0.10.3-pr-477.2",
+    "version": "0.10.3-pr-477.3",
     "description": "A Svelte-native data visualization framework based on the layered grammar of graphics principles.",
     "keywords": [
         "svelte",