@genome-spy/core 0.48.2 → 0.50.0

package/dist/src/marks/mark.js

@@ -14,6 +14,7 @@ import createEncoders, {
     isChannelDefWithScale,
     isChannelWithScale,
     isDatumDef,
+    isExprDef,
     isFieldDef,
     isValueDef,
 } from "../encoder/encoder.js";
@@ -25,9 +26,14 @@ import {
     toHighPrecisionDomainUniform,
     dedupeEncodingFields,
     generateDynamicValueGlslAndUniform,
-    isLargeGenome,
     splitLargeHighPrecision,
     getRangeForGlsl,
+    getAttributeAndArrayTypes,
+    generateDataGlsl,
+    generateDatumGlslAndUniform,
+    generateConditionalEncoderGlsl,
+    PARAM_PREFIX,
+    ATTRIBUTE_PREFIX,
 } from "../gl/glslScaleGenerator.js";
 import GLSL_COMMON from "../gl/includes/common.glsl.js";
 import GLSL_SCALES from "../gl/includes/scales.glsl.js";
@@ -40,7 +46,9 @@ import coalesceProperties from "../utils/propertyCoalescer.js";
 import { isScalar } from "../utils/variableTools.js";
 import { InternMap } from "internmap";
 import ViewError from "../view/viewError.js";
-import { isExprRef } from "../view/paramMediator.js";
+import { isExprRef, validateParameterName } from "../view/paramMediator.js";
+import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
+import { isSinglePointSelection } from "../selection/selection.js";
 
 export const SAMPLE_FACET_UNIFORM = "SAMPLE_FACET_UNIFORM";
 export const SAMPLE_FACET_TEXTURE = "SAMPLE_FACET_TEXTURE";
@@ -56,7 +64,10 @@ export const SAMPLE_FACET_TEXTURE = "SAMPLE_FACET_TEXTURE";
  * @callback DrawFunction
  * @param {number} offset
  * @param {number} count
- *
+ */
+
+/**
+ * @template {MarkProps} [P=MarkProps]
  */
 export default class Mark {
     /**
@@ -80,7 +91,7 @@ export default class Mark {
     constructor(unitView) {
         this.unitView = unitView;
 
-        /** @type {Record<string, import("../types/encoder.js").Encoder>} */
+        /** @type {Partial<Record<Channel, import("../types/encoder.js").Encoder>>} */
         this.encoders = undefined;
 
         // TODO: Consolidate the following webgl stuff into a single object
@@ -138,9 +149,8 @@ export default class Mark {
         /** @type {RangeMap<any>} keep track of facet locations within the vertex array */
         this.rangeMap = new RangeMap();
 
-        // TODO: Implement https://vega.github.io/vega-lite/docs/config.html
-        /** @type {MarkProps} */
-        this.defaultProperties = {
+        // TODO: Implement config: https://vega.github.io/vega-lite/docs/config.html
+        this.defaultProperties = /** @type {P} */ ({
             get clip() {
                 // TODO: Cache once the scales have been resolved
                 // TODO: Only check channels that are used
@@ -161,25 +171,34 @@ export default class Mark {
              * This property is intended for internal usage.
              */
             minBufferSize: 0,
-        };
+        });
 
         /**
          * A properties object that contains the configured mark properties or
          * default values as fallback.
          *
-         * TODO: Proper and comprehensive typings for mark properties
-         *
-         * @type {Partial<MarkProps>}
+         * @type {P}
          * @readonly
          */
         this.properties = coalesceProperties(
             typeof this.unitView.spec.mark == "object"
-                ? () => /** @type {MarkProps} */ (this.unitView.spec.mark)
-                : () => /** @type {MarkProps} */ ({}),
+                ? () => /** @type {P} */ (this.unitView.spec.mark)
+                : () => /** @type {P} */ ({}),
             () => this.defaultProperties
         );
     }
 
+    /**
+     * @param {Partial<P>} props
+     * @protected
+     */
+    augmentDefaultProperties(props) {
+        Object.defineProperties(
+            this.defaultProperties,
+            Object.getOwnPropertyDescriptors(props)
+        );
+    }
+
     get opaque() {
         return false;
     }
@@ -187,10 +206,8 @@ export default class Mark {
     /**
      * Returns attribute info for WebGL attributes that match visual channels.
      *
-     * Note: attributes and channels do not necessarily match.
-     * For example, rectangles have x, y, x2, and y2 channels but only x and y as attributes.
-     *
-     * @returns {string[]}
+     * @returns {import("../spec/channel.js").Channel[]}
+     * @protected
      */
     getAttributes() {
         // override
@@ -225,7 +242,7 @@ export default class Mark {
 
         if (this.isPickingParticipant()) {
             encoding.uniqueId = {
-                field: "_uniqueId", // TODO: Use constant
+                field: UNIQUE_ID_KEY,
             };
         }
 
@@ -246,7 +263,7 @@ export default class Mark {
      * Handles dynamic properties that are not bound to uniforms but need
      * to trigger a graphics update, i.e., rebuild the vertex buffer.
      *
-     * @param {(keyof MarkProps)[]} props
+     * @param {(keyof P)[]} props
      * @protected
      */
     setupExprRefsNeedingGraphicsUpdate(props) {
@@ -358,7 +375,7 @@ export default class Mark {
      * the ranges of the visual channels.
      */
     initializeEncoders() {
-        this.encoders = createEncoders(this);
+        this.encoders = createEncoders(this.unitView, this.encoding);
     }
 
     /**
@@ -401,7 +418,12 @@ export default class Mark {
      */
     // eslint-disable-next-line complexity
     createAndLinkShaders(vertexShader, fragmentShader, extraHeaders = []) {
-        const attributes = this.getAttributes();
+        const shaderChannels = this.getAttributes();
+        const encoders = this.encoders;
+        const sampleFacetMode = this.getSampleFacetMode();
+        if (sampleFacetMode) {
+            extraHeaders.push(`#define ${sampleFacetMode}`);
+        }
 
         // For debugging
         const debugHeader = "// view: " + this.unitView.getPathString();
@@ -416,36 +438,83 @@ export default class Mark {
          */
         const attributeCode = new Set();
 
-        const dedupedEncodingFields = dedupeEncodingFields(this.encoders);
-
-        const sampleFacetMode = this.getSampleFacetMode();
-        if (sampleFacetMode) {
-            extraHeaders.push(`#define ${sampleFacetMode}`);
-        }
+        const dedupedEncodingFields = dedupeEncodingFields(encoders);
 
         /** @type {string[]} */
         const dynamicMarkUniforms = [];
 
-        for (const attribute of attributes) {
-            /** @type {Channel} */
-            let channel;
-            if (attribute in this.encoding) {
-                channel = /** @type {Channel} */ (attribute);
-            } else {
-                continue;
+        const paramPredicates = Object.values(encoders)
+            .flatMap((e) => e.accessors)
+            .map((a) => a.predicate)
+            .filter((p) => p.param);
+
+        /**
+         * Prevent duplicate registration.
+         * @type {Map<string, "single" | "multi" | "range">}
+         */
+        const selectionParameterUniforms = new Map();
+
+        for (const predicate of paramPredicates) {
+            const param = predicate.param;
+            const selection = this.unitView.paramMediator.getValue(param);
+
+            // The selection is supposed to have an empty value at this point
+            // so that we can figure out the type of the selection.
+            if (!selection) {
+                throw new Error(
+                    `Cannot infer selection type as the parameter "${param}" has no value. Please ensure that the parameter is properly defined!`
+                );
             }
 
-            const channelDef = this.encoding[channel];
-            if (!channelDef) {
-                continue;
+            if (isSinglePointSelection(selection)) {
+                // Register a mark uniform for each param. The uniform will have
+                // the value of uniqueId of the selected datum.
+                if (!selectionParameterUniforms.has(param)) {
+                    const uniformName =
+                        PARAM_PREFIX + validateParameterName(param);
+                    selectionParameterUniforms.set(param, "single");
+
+                    dynamicMarkUniforms.push(`    // Selection parameter`);
+                    dynamicMarkUniforms.push(
+                        `    uniform highp uint ${uniformName};`
+                    );
+                    this.#callAfterShaderCompilation.push(() => {
+                        this.registerMarkUniformValue(
+                            uniformName,
+                            { expr: param },
+                            (
+                                /** @type {import("../types/selectionTypes.js").SinglePointSelection} */ selection
+                            ) => selection.uniqueId ?? 0
+                        );
+                    });
+                }
+            } else {
+                throw new Error(
+                    `Unsupported selection (${param}) in condition: ${JSON.stringify(
+                        selection
+                    )}`
+                );
             }
+        }
+
+        /**
+         * @param {Channel} channel
+         * @param {import("../types/encoder.js").Accessor} accessor
+         * @param {number} conditionNumber
+         * @param {import("../types/encoder.js").VegaScale} scale
+         */
+        const addAccessor = (channel, accessor, conditionNumber, scale) => {
+            const channelDef = accessor.channelDef;
 
             if (isValueDef(channelDef)) {
                 if (isExprRef(channelDef.value)) {
                     // An expression that evaluates to a value
-                    const { uniformName, uniformGlsl, scaleGlsl, adjuster } =
-                        generateDynamicValueGlslAndUniform(channel);
-                    scaleCode.push(scaleGlsl);
+                    const { uniformName, uniformGlsl, accessorGlsl, adjuster } =
+                        generateDynamicValueGlslAndUniform(
+                            channel,
+                            conditionNumber
+                        );
+                    scaleCode.push(accessorGlsl);
                     dynamicMarkUniforms.push(uniformGlsl);
 
                     this.#callAfterShaderCompilation.push(() => {
@@ -458,50 +527,127 @@ export default class Mark {
                 } else {
                     // A constant value
                     scaleCode.push(
-                        generateConstantValueGlsl(channel, channelDef.value)
+                        generateConstantValueGlsl(
+                            channel,
+                            conditionNumber,
+                            channelDef.value
+                        ).accessorGlsl
                     );
                 }
+            } else if (isDatumDef(channelDef)) {
+                const { uniformName, uniformGlsl, accessorGlsl } =
+                    generateDatumGlslAndUniform(
+                        channel,
+                        scale,
+                        conditionNumber
+                    );
+
+                dynamicMarkUniforms.push(uniformGlsl);
+                scaleCode.push(accessorGlsl);
+
+                const { largeHp, discrete } = getAttributeAndArrayTypes(
+                    scale,
+                    channel
+                );
+
+                /**
+                 * Discrete variables both numeric and strings must be "indexed",
+                 * 64 bit floats must be converted to vec2.
+                 * 32 bit continuous variables go to GPU as is.
+                 *
+                 * @type {function(import("../spec/channel.js").Scalar):(number | number[])}
+                 */
+                const adjuster =
+                    discrete && "domain" in scale
+                        ? (d) => scale.domain().indexOf(d)
+                        : largeHp
+                        ? splitLargeHighPrecision
+                        : (d) => +d;
+
+                this.#callAfterShaderCompilation.push(() => {
+                    this.registerMarkUniformValue(
+                        uniformName,
+                        channelDef.datum,
+                        adjuster
+                    );
+                });
+            } else if (isFieldDef(channelDef)) {
+                const fields = dedupedEncodingFields.get([
+                    channelDef.field,
+                    true,
+                ]);
+                const { attributeGlsl, accessorGlsl } = generateDataGlsl(
+                    channel,
+                    scale,
+                    conditionNumber,
+                    fields?.includes(channel) ? fields : undefined
+                );
+                attributeCode.add(attributeGlsl);
+                scaleCode.push(accessorGlsl);
+            } else if (isExprDef(channelDef)) {
+                const { attributeGlsl, accessorGlsl } = generateDataGlsl(
+                    channel,
+                    scale,
+                    conditionNumber
+                );
+                attributeCode.add(attributeGlsl);
+                scaleCode.push(accessorGlsl);
             } else {
+                throw new ViewError(
+                    `Unsupported channel definition: ${JSON.stringify(
+                        channelDef
+                    )}`,
+                    this.unitView
+                );
+            }
+        };
+
+        for (const [channel, encoder] of Object.entries(encoders)) {
+            if (!shaderChannels.includes(channel)) {
+                continue;
+            }
+
+            const { channelDef, accessors, scale } = encoder;
+
+            // Generate accessors, one for each condition -------------
+
+            for (let i = 0; i < accessors.length; i++) {
+                addAccessor(channel, accessors[i], i, scale);
+            }
+
+            // Generate scale if needed -------------------------------
+
+            if (scale) {
                 const resolutionChannel =
                     (isChannelDefWithScale(channelDef) &&
                         channelDef.resolutionChannel) ||
                     channel;
 
+                // TODO: The event listener should be in the scale, not the resolution
                 const scaleResolution = isChannelWithScale(resolutionChannel)
                     ? this.unitView.getScaleResolution(resolutionChannel)
                     : null;
 
-                // Channels that share the same quantitative field
-                // TODO: It should be ok to share a categorical field if the channels
-                // share the same scale, e.g., primary and secondary positional channels
-                const sharedChannels = isFieldDef(channelDef)
-                    ? dedupedEncodingFields.get([channelDef.field, true])
-                    : [channel];
-
-                const generated = generateScaleGlsl(
-                    channel,
-                    scaleResolution,
-                    channelDef,
-                    sharedChannels?.includes(channel)
-                        ? sharedChannels
-                        : [channel]
-                );
+                const {
+                    glsl,
+                    domainUniform,
+                    domainUniformName,
+                    rangeUniform,
+                    rangeUniformName,
+                } = generateScaleGlsl(channel, scale, channelDef);
 
-                scaleCode.push(generated.glsl);
-                dynamicMarkUniforms.push(generated.domainUniform);
-                dynamicMarkUniforms.push(generated.rangeUniform);
-                attributeCode.add(generated.attributeGlsl);
+                scaleCode.push(glsl);
+                dynamicMarkUniforms.push(domainUniform);
+                dynamicMarkUniforms.push(rangeUniform);
 
-                if (generated.rangeUniform) {
+                if (rangeUniform) {
                     this.#callAfterShaderCompilation.push(() => {
-                        const rangeSetter = this.createMarkUniformSetter(
-                            generated.rangeName
-                        );
+                        const rangeSetter =
+                            this.createMarkUniformSetter(rangeUniformName);
 
                         const set = () =>
-                            rangeSetter(
-                                getRangeForGlsl(scaleResolution.scale, channel)
-                            );
+                            rangeSetter(getRangeForGlsl(scale, channel));
+                        // TODO: The event listener should be in the scale, not the resolution
                         scaleResolution.addEventListener("range", set);
 
                         // Initial value
@@ -509,47 +655,10 @@ export default class Mark {
                     });
                 }
 
-                if (generated.markUniformGlsl) {
-                    if (!isDatumDef(channelDef)) {
-                        throw new Error("Bug!");
-                    }
-
-                    const encoder = this.encoders[channel];
-
-                    const indexer = encoder.indexer;
-                    const hp = isHighPrecisionScale(encoder.scale.type);
-                    const largeHp = hp && isLargeGenome(encoder.scale.domain());
-
-                    /**
-                     * Discrete variables both numeric and strings must be "indexed",
-                     * 64 bit floats must be converted to vec2.
-                     * 32 bit continuous variables go to GPU as is.
-                     *
-                     * @type {function(import("../spec/channel.js").Scalar):(number | number[])}
-                     */
-                    const adjuster = indexer
-                        ? indexer
-                        : largeHp
-                        ? splitLargeHighPrecision
-                        : (d) => +d;
-
-                    dynamicMarkUniforms.push(generated.markUniformGlsl);
-
-                    this.#callAfterShaderCompilation.push(() => {
-                        this.registerMarkUniformValue(
-                            generated.attributeName,
-                            channelDef.datum,
-                            adjuster
-                        );
-                    });
-                }
-
-                if (generated.domainUniform) {
+                if (domainUniform) {
                     this.#callAfterShaderCompilation.push(() => {
-                        const domainSetter = this.createMarkUniformSetter(
-                            generated.domainUniformName
-                        );
-                        const scale = scaleResolution.scale;
+                        const domainSetter =
+                            this.createMarkUniformSetter(domainUniformName);
                         const set = () => {
                             const domain = isDiscrete(scale.type)
                                 ? [0, scale.domain().length]
@@ -562,6 +671,7 @@ export default class Mark {
                             );
                         };
 
+                        // TODO: The event listener should be in the scale, not the resolution
                         scaleResolution.addEventListener("domain", set);
 
                         // Initial value
@@ -569,8 +679,27 @@ export default class Mark {
                     });
                 }
             }
+
+            // Generate conditional encoder -------------------------------
+
+            scaleCode.push(generateConditionalEncoderGlsl(channel, accessors));
         }
 
+        // Generate a function that checks if the datum is subject to any point selection
+        const conditions = [...selectionParameterUniforms.entries()]
+            .filter(([, v]) => v == "single")
+            .map(
+                ([param]) =>
+                    `${PARAM_PREFIX}${param} == ${ATTRIBUTE_PREFIX}uniqueId`
+            );
+        scaleCode.push(
+            "bool isPointSelected() {",
+            this.encoders.uniqueId && conditions.length > 0
+                ? `    return ${conditions.join(" || ")};`
+                : "    return false;",
+            "}"
+        );
+
         const vertexPrecision = "precision highp float;\nprecision highp int;";
 
         /**
@@ -834,13 +963,12 @@ export default class Mark {
 
     /**
      * Returns true if this mark instance participates in picking.
-     *
-     * TODO: Check if tooltip is enabled,
-     * TODO: Check if selection (when it's implemented) is enabled
      */
     isPickingParticipant() {
-        // TODO: Should check encoding instead
-        if (this.properties.tooltip === null) {
+        if (
+            this.properties.tooltip === null &&
+            !this.unitView.paramMediator.hasPointSelections()
+        ) {
             // Disabled
             return false;
         }
@@ -1153,14 +1281,14 @@ export default class Mark {
             // Because glViewport accepts only integers, we subtract the rounding
             // errors from xyOffsets to guarantee that graphics in clipped
             // and non-clipped viewports align correctly
-            const roundedCoords = physicalGlCoords.map((x) => Math.round(x));
-            const [xError, yError] = physicalGlCoords.map(
-                (x, i) => x - roundedCoords[i]
-            );
+            const roundedCoords =
+                /** @type {[number, number, number, number]} */ (
+                    physicalGlCoords.map((x) => Math.floor(x))
+                );
+            const xError = physicalGlCoords[0] - roundedCoords[0];
+            const yError = physicalGlCoords[1] - roundedCoords[1];
 
-            // @ts-ignore
             gl.viewport(...roundedCoords);
-            // @ts-ignore
             gl.scissor(...roundedCoords);
             gl.enable(gl.SCISSOR_TEST);
 

package/dist/src/marks/markUtils.d.ts

@@ -18,6 +18,31 @@ export function fixStroke(encoding: import("../spec/channel.js").Encoding, fille
  * @param {boolean} filled
  */
 export function fixFill(encoding: import("../spec/channel.js").Encoding, filled: boolean): void;
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").PointProps}
+ */
+export function isPointProps(props: import("../spec/mark.js").MarkProps): props is import("../spec/mark.js").PointProps;
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").RectProps}
+ */
+export function isRectProps(props: import("../spec/mark.js").MarkProps): props is import("../spec/mark.js").RectProps;
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").RuleProps}
+ */
+export function isRuleProps(props: import("../spec/mark.js").MarkProps): props is import("../spec/mark.js").RuleProps;
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").TextProps}
+ */
+export function isTextProps(props: import("../spec/mark.js").MarkProps): props is import("../spec/mark.js").TextProps;
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").LinkProps}
+ */
+export function isLinkProps(props: import("../spec/mark.js").MarkProps): props is import("../spec/mark.js").LinkProps;
 export type Encoding = import("../spec/channel.js").Encoding;
 export type Channel = import("../spec/channel.js").Channel;
 //# sourceMappingURL=markUtils.d.ts.map

package/dist/src/marks/markUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markUtils.d.ts","sourceRoot":"","sources":["../../../src/marks/markUtils.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;GAGG;AACH,wCAHW,QAAQ,WACR,OAAO,oBAAoB,EAAE,wBAAwB,QAoD/D;AAED;;;GAGG;AACH,oCAHW,OAAO,oBAAoB,EAAE,QAAQ,UACrC,OAAO,QAyBjB;AAED;;;GAGG;AACH,kCAHW,OAAO,oBAAoB,EAAE,QAAQ,UACrC,OAAO,QAyBjB;uBApHY,OAAO,oBAAoB,EAAE,QAAQ;sBACrC,OAAO,oBAAoB,EAAE,OAAO"}
+{"version":3,"file":"markUtils.d.ts","sourceRoot":"","sources":["../../../src/marks/markUtils.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;GAGG;AACH,wCAHW,QAAQ,WACR,OAAO,oBAAoB,EAAE,wBAAwB,QAoD/D;AAED;;;GAGG;AACH,oCAHW,OAAO,oBAAoB,EAAE,QAAQ,UACrC,OAAO,QAyBjB;AAED;;;GAGG;AACH,kCAHW,OAAO,oBAAoB,EAAE,QAAQ,UACrC,OAAO,QAyBjB;AAED;;;GAGG;AACH,oCAHW,OAAO,iBAAiB,EAAE,SAAS,iDAK7C;AAED;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,gDAK7C;AAED;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,gDAK7C;AAED;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,gDAK7C;AAED;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,gDAK7C;uBA5JY,OAAO,oBAAoB,EAAE,QAAQ;sBACrC,OAAO,oBAAoB,EAAE,OAAO"}

package/dist/src/marks/markUtils.js

@@ -37,7 +37,7 @@ export function fixPositional(encoding, channel) {
         if (!secondary) {
             if (primary.type == "quantitative") {
                 // Bar plot, anchor the other end to zero
-                secondary = { datum: 0 };
+                secondary = { datum: 0, contributesToScaleDomain: false };
             } else {
                 secondary = { ...primary };
 
@@ -123,3 +123,43 @@ export function fixFill(encoding, filled) {
         }
     }
 }
+
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").PointProps}
+ */
+export function isPointProps(props) {
+    return props.type === "point";
+}
+
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").RectProps}
+ */
+export function isRectProps(props) {
+    return props.type === "point";
+}
+
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").RuleProps}
+ */
+export function isRuleProps(props) {
+    return props.type === "point";
+}
+
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").TextProps}
+ */
+export function isTextProps(props) {
+    return props.type === "point";
+}
+
+/**
+ * @param {import("../spec/mark.js").MarkProps} props
+ * @returns {props is import("../spec/mark.js").LinkProps}
+ */
+export function isLinkProps(props) {
+    return props.type === "point";
+}

package/dist/src/marks/point.common.glsl.js

@@ -1,2 +1,2 @@
-const shader = "layout(std140)uniform Mark{/***The stroke should only grow inwards,e.g,the diameter/outline is not affected by the stroke width.*Thus,a point that has a zero size has no visible stroke. This allows strokes to be used with*geometric zoom,etc.*/uniform bool uInwardStroke;uniform mediump float uScaleFactor;uniform mediump float uZoomLevel;uniform highp float uSemanticThreshold;uniform mediump float uGradientStrength;\n#pragma markUniforms\n};";
+const shader = "layout(std140)uniform Mark{/***The stroke should only grow inwards,e.g,the diameter/outline is not affected by the stroke width.*Thus,a point that has a zero size has no visible stroke. This allows strokes to be used with*geometric zoom,etc.*/uniform bool uInwardStroke;uniform float uMinPickingSize;uniform mediump float uScaleFactor;uniform mediump float uZoomLevel;uniform highp float uSemanticThreshold;uniform mediump float uGradientStrength;\n#pragma markUniforms\n};";
 export default shader;

package/dist/src/marks/point.d.ts

@@ -1,4 +1,11 @@
-export default class PointMark extends Mark {
+/**
+ * @extends {Mark<import("../spec/mark.js").PointProps>}
+ */
+export default class PointMark extends Mark<import("../spec/mark.js").PointProps> {
+    /**
+     * @param {import("../view/unitView.js").default} unitView
+     */
+    constructor(unitView: import("../view/unitView.js").default);
     sampledSemanticScores: Float32Array;
     getSemanticThreshold(): number;
     #private;

package/dist/src/marks/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/marks/point.js"],"names":[],"mappings":"AAmBA;IA0HY,oCAMC;IA6DT,+BAkBC;;CAgDJ;iBAvQgB,WAAW"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/marks/point.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH;IAGI;;OAEG;IACH,sBAFW,OAAO,qBAAqB,EAAE,OAAO,EA6C/C;IA0EO,oCAMC;IAkET,+BAkBC;;CAgDJ;iBAhRgB,WAAW"}