genesys-spark-chart-components 4.202.0 → 4.203.0

package/dist/esm/gux-visualization-beta.entry.js

@@ -1,5 +1,5 @@
 import { r as registerInstance, c as createEvent, h as h$1, g as getElement } from './index-WPqt-wWR.js';
-import { a as DEFAULT_DOMAIN_COLOR, D as DEFAULT_LABEL_COLOR, t as trackComponent } from './color-palette-CqY6Km9m.js';
+import { a as DEFAULT_DOMAIN_COLOR, D as DEFAULT_LABEL_COLOR, t as trackComponent } from './color-palette-DyPalgli.js';
 
 // Note: This regex matches even invalid JSON strings, but since we’re
 // working on the output of `JSON.stringify` we know that only valid strings
@@ -44672,7 +44672,7 @@ var expression$1 = {
   }
 };
 
-var version$1$1 = "6.4.1";
+var version$1$1 = "6.4.2";
 var pkg$1 = {
 	version: version$1$1};
 
@@ -44904,6 +44904,12 @@ const entries$1 = Object.entries;
 function isBoolean(b) {
     return b === true || b === false;
 }
+/**
+ * Returns true if the value is a primitive type.
+ */
+function isPrimitive(v) {
+    return isString(v) || isNumber$1(v) || isBoolean(v);
+}
 /**
  * Convert a string into a valid variable name
  */
@@ -46378,6 +46384,10 @@ const MORE_THAN_ONE_SORT = 'Domains that should be unioned has conflicting sort
 const FACETED_INDEPENDENT_DIFFERENT_SOURCES = 'Detected faceted independent scales that union domain of multiple fields from different data sources. We will use the first field. The result view size may be incorrect.';
 const FACETED_INDEPENDENT_SAME_FIELDS_DIFFERENT_SOURCES = 'Detected faceted independent scales that union domain of the same fields from different source. We will assume that this is the same field from a different fork of the same data source. However, if this is not the case, the result view size may be incorrect.';
 const FACETED_INDEPENDENT_SAME_SOURCE = 'Detected faceted independent scales that union domain of multiple fields from the same data source. We will use the first field. The result view size may be incorrect.';
+// LEGEND
+function legendValuesUnioned(channelA, channelB) {
+    return `Unioning discrete legend values from ${channelA} and ${channelB}.`;
+}
 // STACK
 function cannotStackRangedMark(channel) {
     return `Cannot stack "${channel}" if there is already "${channel}2".`;
@@ -48388,7 +48398,7 @@ function getFieldOrDatumDef(channelDef) {
  * Convert type to full, lowercase type, or augment the fieldDef with a default type if missing.
  */
 function initChannelDef(channelDef, channel, config, opt = {}) {
-    if (isString(channelDef) || isNumber$1(channelDef) || isBoolean$2(channelDef)) {
+    if (isPrimitive(channelDef)) {
         const primitiveType = isString(channelDef) ? 'string' : isNumber$1(channelDef) ? 'number' : 'boolean';
         warn(primitiveChannelDef(channel, primitiveType, channelDef));
         return { value: channelDef };
@@ -53961,8 +53971,11 @@ function tooltipRefForEncoding(encoding, stack, config, { reactiveGeom } = {}) {
  * Transforms a tooltip value that is an array to a string with line breaks
  */
 function addLineBreaksToTooltip(channelDef, config, expr = 'datum') {
-    if (isFieldDef(channelDef) && isDiscrete$1(channelDef.type) && !hasProperty(channelDef, 'format')) {
-        const fieldString = `datum["${channelDef.field}"]`;
+    if (isFieldDef(channelDef) &&
+        isDiscrete$1(channelDef.type) &&
+        !getFormatMixins(channelDef).format &&
+        !getFormatMixins(channelDef).formatType) {
+        const fieldString = `${expr}["${channelDef.field}"]`;
         return {
             signal: `isValid(${fieldString}) ? isArray(${fieldString}) ? join(${fieldString}, '\\n') : ${fieldString} : ""+${fieldString}`,
         };
@@ -56983,298 +56996,6 @@ function mergeSymbolType(st1, st2) {
     return st1;
 }
 
-function setLegendEncode(legend, part, vgProp, vgRef) {
-    legend.encode ??= {};
-    legend.encode[part] ??= {};
-    legend.encode[part].update ??= {};
-    // @ts-expect-error expression is too complex for typescript to understand
-    legend.encode[part].update[vgProp] = vgRef;
-}
-function assembleLegends(model) {
-    const legendComponentIndex = model.component.legends;
-    const legendByDomain = {};
-    for (const channel of keys(legendComponentIndex)) {
-        const scaleComponent = model.getScaleComponent(channel);
-        const domainHash = stringify$1(scaleComponent.get('domains'));
-        if (legendByDomain[domainHash]) {
-            for (const mergedLegendComponent of legendByDomain[domainHash]) {
-                const merged = mergeLegendComponent(mergedLegendComponent, legendComponentIndex[channel]);
-                if (!merged) {
-                    // If cannot merge, need to add this legend separately
-                    legendByDomain[domainHash].push(legendComponentIndex[channel]);
-                }
-            }
-        }
-        else {
-            legendByDomain[domainHash] = [legendComponentIndex[channel].clone()];
-        }
-    }
-    const legends = vals(legendByDomain)
-        .flat()
-        .map((l) => assembleLegend(l, model.config))
-        .filter((l) => l !== undefined);
-    return legends;
-}
-function assembleLegend(legendCmpt, config) {
-    const { disable, labelExpr, selections, ...legend } = legendCmpt.combine();
-    if (disable) {
-        return undefined;
-    }
-    if (config.aria === false && legend.aria == undefined) {
-        legend.aria = false;
-    }
-    if (legend.encode?.symbols) {
-        const out = legend.encode.symbols.update;
-        if (out.fill && out.fill['value'] !== 'transparent' && !out.stroke && !legend.stroke) {
-            // For non color channel's legend, we need to override symbol stroke config from Vega config if stroke channel is not used.
-            out.stroke = { value: 'transparent' };
-        }
-        // Remove properties that the legend is encoding.
-        for (const property of LEGEND_SCALE_CHANNELS) {
-            if (legend[property]) {
-                delete out[property];
-            }
-        }
-    }
-    if (!legend.title) {
-        // title schema doesn't include null, ''
-        delete legend.title;
-    }
-    if (labelExpr !== undefined) {
-        let expr = labelExpr;
-        if (legend.encode?.labels?.update && isSignalRef(legend.encode.labels.update.text)) {
-            expr = replaceAll(labelExpr, 'datum.label', legend.encode.labels.update.text.signal);
-        }
-        setLegendEncode(legend, 'labels', 'text', { signal: expr });
-    }
-    return legend;
-}
-
-function assembleProjections(model) {
-    if (isLayerModel(model) || isConcatModel(model)) {
-        return assembleProjectionsForModelAndChildren(model);
-    }
-    else {
-        return assembleProjectionForModel(model);
-    }
-}
-function assembleProjectionsForModelAndChildren(model) {
-    return model.children.reduce((projections, child) => {
-        return projections.concat(child.assembleProjections());
-    }, assembleProjectionForModel(model));
-}
-function assembleProjectionForModel(model) {
-    const component = model.component.projection;
-    if (!component || component.merged) {
-        return [];
-    }
-    const projection = component.combine();
-    const { name } = projection; // we need to extract name so that it is always present in the output and pass TS type validation
-    if (!component.data) {
-        // generate custom projection, no automatic fitting
-        return [
-            {
-                name,
-                // translate to center by default
-                translate: { signal: '[width / 2, height / 2]' },
-                // parameters, overwrite default translate if specified
-                ...projection,
-            },
-        ];
-    }
-    else {
-        // generate projection that uses extent fitting
-        const size = {
-            signal: `[${component.size.map((ref) => ref.signal).join(', ')}]`,
-        };
-        const fits = component.data.reduce((sources, data) => {
-            const source = isSignalRef(data) ? data.signal : `data('${model.lookupDataSource(data)}')`;
-            if (!contains(sources, source)) {
-                // build a unique list of sources
-                sources.push(source);
-            }
-            return sources;
-        }, []);
-        if (fits.length <= 0) {
-            throw new Error("Projection's fit didn't find any data sources");
-        }
-        return [
-            {
-                name,
-                size,
-                fit: {
-                    signal: fits.length > 1 ? `[${fits.join(', ')}]` : fits[0],
-                },
-                ...projection,
-            },
-        ];
-    }
-}
-
-const PROJECTION_PROPERTIES = [
-    'type',
-    'clipAngle',
-    'clipExtent',
-    'center',
-    'rotate',
-    'precision',
-    'reflectX',
-    'reflectY',
-    'coefficient',
-    'distance',
-    'fraction',
-    'lobes',
-    'parallel',
-    'radius',
-    'ratio',
-    'spacing',
-    'tilt',
-];
-
-class ProjectionComponent extends Split {
-    specifiedProjection;
-    size;
-    data;
-    merged = false;
-    constructor(name, specifiedProjection, size, data) {
-        super({ ...specifiedProjection }, // all explicit properties of projection
-        { name });
-        this.specifiedProjection = specifiedProjection;
-        this.size = size;
-        this.data = data;
-    }
-    /**
-     * Whether the projection parameters should fit provided data.
-     */
-    get isFit() {
-        return !!this.data;
-    }
-}
-
-function parseProjection(model) {
-    model.component.projection = isUnitModel(model) ? parseUnitProjection(model) : parseNonUnitProjections(model);
-}
-function parseUnitProjection(model) {
-    if (model.hasProjection) {
-        const proj = replaceExprRef(model.specifiedProjection);
-        const fit = !(proj && (proj.scale != null || proj.translate != null));
-        const size = fit ? [model.getSizeSignalRef('width'), model.getSizeSignalRef('height')] : undefined;
-        const data = fit ? gatherFitData(model) : undefined;
-        const projComp = new ProjectionComponent(model.projectionName(true), {
-            ...replaceExprRef(model.config.projection),
-            ...proj,
-        }, size, data);
-        if (!projComp.get('type')) {
-            projComp.set('type', 'equalEarth', false);
-        }
-        return projComp;
-    }
-    return undefined;
-}
-function gatherFitData(model) {
-    const data = [];
-    const { encoding } = model;
-    for (const posssiblePair of [
-        [LONGITUDE, LATITUDE],
-        [LONGITUDE2, LATITUDE2],
-    ]) {
-        if (getFieldOrDatumDef(encoding[posssiblePair[0]]) || getFieldOrDatumDef(encoding[posssiblePair[1]])) {
-            data.push({
-                signal: model.getName(`geojson_${data.length}`),
-            });
-        }
-    }
-    if (model.channelHasField(SHAPE) && model.typedFieldDef(SHAPE).type === GEOJSON) {
-        data.push({
-            signal: model.getName(`geojson_${data.length}`),
-        });
-    }
-    if (data.length === 0) {
-        // main source is geojson, so we can just use that
-        data.push(model.requestDataName(DataSourceType.Main));
-    }
-    return data;
-}
-function mergeIfNoConflict(first, second) {
-    const allPropertiesShared = every(PROJECTION_PROPERTIES, (prop) => {
-        // neither has the property
-        if (!has$1(first.explicit, prop) && !has$1(second.explicit, prop)) {
-            return true;
-        }
-        // both have property and an equal value for property
-        if (has$1(first.explicit, prop) &&
-            has$1(second.explicit, prop) &&
-            // some properties might be signals or objects and require hashing for comparison
-            deepEqual(first.get(prop), second.get(prop))) {
-            return true;
-        }
-        return false;
-    });
-    const size = deepEqual(first.size, second.size);
-    if (size) {
-        if (allPropertiesShared) {
-            return first;
-        }
-        else if (deepEqual(first.explicit, {})) {
-            return second;
-        }
-        else if (deepEqual(second.explicit, {})) {
-            return first;
-        }
-    }
-    // if all properties don't match, let each unit spec have its own projection
-    return null;
-}
-function parseNonUnitProjections(model) {
-    if (model.children.length === 0) {
-        return undefined;
-    }
-    let nonUnitProjection;
-    // parse all children first
-    for (const child of model.children) {
-        parseProjection(child);
-    }
-    // analyze parsed projections, attempt to merge
-    const mergable = every(model.children, (child) => {
-        const projection = child.component.projection;
-        if (!projection) {
-            // child layer does not use a projection
-            return true;
-        }
-        else if (!nonUnitProjection) {
-            // cached 'projection' is null, cache this one
-            nonUnitProjection = projection;
-            return true;
-        }
-        else {
-            const merge = mergeIfNoConflict(nonUnitProjection, projection);
-            if (merge) {
-                nonUnitProjection = merge;
-            }
-            return !!merge;
-        }
-    });
-    // if cached one and all other children share the same projection,
-    if (nonUnitProjection && mergable) {
-        // so we can elevate it to the layer level
-        const name = model.projectionName(true);
-        const modelProjection = new ProjectionComponent(name, nonUnitProjection.specifiedProjection, nonUnitProjection.size, duplicate(nonUnitProjection.data));
-        // rename and assign all others as merged
-        for (const child of model.children) {
-            const projection = child.component.projection;
-            if (projection) {
-                if (projection.isFit) {
-                    modelProjection.data.push(...child.component.projection.data);
-                }
-                child.renameProjection(projection.get('name'), name);
-                projection.merged = true;
-            }
-        }
-        return modelProjection;
-    }
-    return undefined;
-}
-
 function rangeFormula(model, fieldDef, channel, config) {
     if (binRequiresRange(fieldDef, channel)) {
         // read format from axis or legend, if there is no format then use config.numberFormat
@@ -59501,7 +59222,7 @@ function parseSingleChannelDomain(scaleType, domain, model, channel) {
                     sort: sort === true || !isObject(sort)
                         ? {
                             field: model.vgField(channel, {}),
-                            op: 'min', // min or max doesn't matter since we sort by the start of the bin range
+                            op: 'min',
                         }
                         : sort,
                 },
@@ -59833,6 +59554,423 @@ function assembleDomain(model, channel) {
     return mergeDomains(domains);
 }
 
+function setLegendEncode(legend, part, vgProp, vgRef) {
+    legend.encode ??= {};
+    legend.encode[part] ??= {};
+    legend.encode[part].update ??= {};
+    // @ts-expect-error expression is too complex for typescript to understand
+    legend.encode[part].update[vgProp] = vgRef;
+}
+/**
+ * Determines the underlying field name for a given scale channel within a model hierarchy.
+ * @param model - The model to search for the field definition
+ * @param channel - The scale channel (e.g., 'color', 'size', 'shape') to find the field for
+ * @returns The field name if found; otherwise undefined
+ */
+function getFieldKeyForChannel(model, channel) {
+    if (isUnitModel(model)) {
+        const fd = model.fieldDef(channel);
+        if (fd?.field) {
+            return fd.field;
+        }
+    }
+    // Use explicit fields from children
+    const childFields = (model.children ?? [])
+        .map((child) => getFieldKeyForChannel(child, channel))
+        .filter((f) => !!f);
+    if (childFields.length > 0) {
+        const unique$1 = unique(childFields, hash);
+        if (unique$1.length === 1) {
+            return unique$1[0];
+        }
+        return undefined;
+    }
+    return undefined;
+}
+function legendsAreMergeCompatible(model, channelA, channelB) {
+    if (channelA === channelB)
+        return true;
+    const typeA = model.getScaleType(channelA);
+    const typeB = model.getScaleType(channelB);
+    if (!typeA || !typeB)
+        return false;
+    // Only require discrete/continuous compatibility here. Domain handling is done later.
+    const aIsDiscrete = hasDiscreteDomain(typeA);
+    const bIsDiscrete = hasDiscreteDomain(typeB);
+    return aIsDiscrete === bIsDiscrete;
+}
+function getLegendGroupKey(fieldKey, channel) {
+    return fieldKey ? `field:${fieldKey}` : `channel:${String(channel)}`;
+}
+function extractDiscreteValuesFromDomain(domain) {
+    if (isArray(domain)) {
+        const primitives = domain.filter(isPrimitive);
+        return primitives.length > 0 ? primitives : null;
+    }
+    if (isDataRefUnionedDomain(domain)) {
+        const values = [];
+        values.push(...domain.fields.flatMap((f) => (isArray(f) ? f.filter(isPrimitive) : [])));
+        if (values.length > 0) {
+            return unique(values, hash);
+        }
+    }
+    return null;
+}
+/**
+ * Compute the union of discrete values from the domains of two channels.
+ *
+ * @param model - The model to compute the union of discrete values for
+ * @param channelA - The first channel to compute the union of discrete values for
+ * @param channelB - The second channel to compute the union of discrete values for
+ * @returns The union of discrete values
+ */
+function getDiscreteValuesForChannel(model, channel) {
+    try {
+        const domain = assembleDomain(model, channel);
+        return extractDiscreteValuesFromDomain(domain);
+    }
+    catch {
+        return null;
+    }
+}
+function unionDiscreteValuesForChannels(model, channelA, channelB) {
+    const vA = getDiscreteValuesForChannel(model, channelA);
+    const vB = getDiscreteValuesForChannel(model, channelB);
+    return vA && vB ? unique([...vA, ...vB], hash) : null;
+}
+function setImplicitLegendValues(cmpt, values, warnMessage) {
+    if (values && values.length > 0) {
+        const valuesProp = cmpt.getWithExplicit('values');
+        if (!valuesProp?.explicit) {
+            if (warnMessage) {
+                warn(warnMessage);
+            }
+            cmpt.set('values', values, false);
+        }
+    }
+}
+function domainsExplicitAndEqual(model, channelA, channelB) {
+    const scA = model.getScaleComponent(channelA);
+    const scB = model.getScaleComponent(channelB);
+    if (!scA || !scB)
+        return false;
+    const dA = scA.getWithExplicit('domains');
+    const dB = scB.getWithExplicit('domains');
+    if (!(dA?.explicit && dB?.explicit))
+        return false;
+    const assembledA = assembleDomain(model, channelA);
+    const assembledB = assembleDomain(model, channelB);
+    return hash(assembledA) === hash(assembledB);
+}
+/**
+ * Assemble legends for a model. We group legends by the underlying field used by the encoding.
+ *
+ * @param model - The model to assemble legends for
+ * @returns The assembled legends
+ */
+function assembleLegends(model) {
+    const legendComponentIndex = model.component.legends;
+    const legendsByGroup = {};
+    for (const channel of keys(legendComponentIndex)) {
+        const fieldKey = getFieldKeyForChannel(model, channel);
+        const groupKey = getLegendGroupKey(fieldKey, channel);
+        if (!legendsByGroup[groupKey]) {
+            legendsByGroup[groupKey] = [{ channel, cmpt: legendComponentIndex[channel].clone() }];
+            continue;
+        }
+        let mergedIntoExisting = false;
+        for (const existing of legendsByGroup[groupKey]) {
+            if (!legendsAreMergeCompatible(model, existing.channel, channel)) {
+                continue;
+            }
+            const merged = mergeLegendComponent(existing.cmpt, legendComponentIndex[channel]);
+            if (merged) {
+                const typeA = model.getScaleType(existing.channel);
+                const typeB = model.getScaleType(channel);
+                if (typeA && typeB && hasDiscreteDomain(typeA) && hasDiscreteDomain(typeB)) {
+                    if (domainsExplicitAndEqual(model, existing.channel, channel)) {
+                        setImplicitLegendValues(existing.cmpt, getDiscreteValuesForChannel(model, existing.channel));
+                    }
+                    else {
+                        setImplicitLegendValues(existing.cmpt, unionDiscreteValuesForChannels(model, existing.channel, channel), 
+                        // Warn when unioning discrete legend values so that users are aware
+                        legendValuesUnioned(existing.channel, channel));
+                    }
+                }
+                mergedIntoExisting = true;
+                break;
+            }
+        }
+        if (!mergedIntoExisting) {
+            legendsByGroup[groupKey].push({ channel, cmpt: legendComponentIndex[channel].clone() });
+        }
+    }
+    const legends = vals(legendsByGroup)
+        .flat()
+        .map((entry) => assembleLegend(entry.cmpt, model.config))
+        .filter((l) => l !== undefined);
+    return legends;
+}
+function assembleLegend(legendCmpt, config) {
+    const { disable, labelExpr, selections, ...legend } = legendCmpt.combine();
+    if (disable) {
+        return undefined;
+    }
+    if (config.aria === false && legend.aria == undefined) {
+        legend.aria = false;
+    }
+    if (legend.encode?.symbols) {
+        const out = legend.encode.symbols.update;
+        if (out.fill && out.fill['value'] !== 'transparent' && !out.stroke && !legend.stroke) {
+            // For non color channel's legend, we need to override symbol stroke config from Vega config if stroke channel is not used.
+            out.stroke = { value: 'transparent' };
+        }
+        // Remove properties that the legend is encoding.
+        for (const property of LEGEND_SCALE_CHANNELS) {
+            if (legend[property]) {
+                delete out[property];
+            }
+        }
+    }
+    if (!legend.title) {
+        // title schema doesn't include null, ''
+        delete legend.title;
+    }
+    if (labelExpr !== undefined) {
+        let expr = labelExpr;
+        if (legend.encode?.labels?.update && isSignalRef(legend.encode.labels.update.text)) {
+            expr = replaceAll(labelExpr, 'datum.label', legend.encode.labels.update.text.signal);
+        }
+        setLegendEncode(legend, 'labels', 'text', { signal: expr });
+    }
+    return legend;
+}
+
+function assembleProjections(model) {
+    if (isLayerModel(model) || isConcatModel(model)) {
+        return assembleProjectionsForModelAndChildren(model);
+    }
+    else {
+        return assembleProjectionForModel(model);
+    }
+}
+function assembleProjectionsForModelAndChildren(model) {
+    return model.children.reduce((projections, child) => {
+        return projections.concat(child.assembleProjections());
+    }, assembleProjectionForModel(model));
+}
+function assembleProjectionForModel(model) {
+    const component = model.component.projection;
+    if (!component || component.merged) {
+        return [];
+    }
+    const projection = component.combine();
+    const { name } = projection; // we need to extract name so that it is always present in the output and pass TS type validation
+    if (!component.data) {
+        // generate custom projection, no automatic fitting
+        return [
+            {
+                name,
+                // translate to center by default
+                translate: { signal: '[width / 2, height / 2]' },
+                // parameters, overwrite default translate if specified
+                ...projection,
+            },
+        ];
+    }
+    else {
+        // generate projection that uses extent fitting
+        const size = {
+            signal: `[${component.size.map((ref) => ref.signal).join(', ')}]`,
+        };
+        const fits = component.data.reduce((sources, data) => {
+            const source = isSignalRef(data) ? data.signal : `data('${model.lookupDataSource(data)}')`;
+            if (!contains(sources, source)) {
+                // build a unique list of sources
+                sources.push(source);
+            }
+            return sources;
+        }, []);
+        if (fits.length <= 0) {
+            throw new Error("Projection's fit didn't find any data sources");
+        }
+        return [
+            {
+                name,
+                size,
+                fit: {
+                    signal: fits.length > 1 ? `[${fits.join(', ')}]` : fits[0],
+                },
+                ...projection,
+            },
+        ];
+    }
+}
+
+const PROJECTION_PROPERTIES = [
+    'type',
+    'clipAngle',
+    'clipExtent',
+    'center',
+    'rotate',
+    'precision',
+    'reflectX',
+    'reflectY',
+    'coefficient',
+    'distance',
+    'fraction',
+    'lobes',
+    'parallel',
+    'radius',
+    'ratio',
+    'spacing',
+    'tilt',
+];
+
+class ProjectionComponent extends Split {
+    specifiedProjection;
+    size;
+    data;
+    merged = false;
+    constructor(name, specifiedProjection, size, data) {
+        super({ ...specifiedProjection }, // all explicit properties of projection
+        { name });
+        this.specifiedProjection = specifiedProjection;
+        this.size = size;
+        this.data = data;
+    }
+    /**
+     * Whether the projection parameters should fit provided data.
+     */
+    get isFit() {
+        return !!this.data;
+    }
+}
+
+function parseProjection(model) {
+    model.component.projection = isUnitModel(model) ? parseUnitProjection(model) : parseNonUnitProjections(model);
+}
+function parseUnitProjection(model) {
+    if (model.hasProjection) {
+        const proj = replaceExprRef(model.specifiedProjection);
+        const fit = !(proj && (proj.scale != null || proj.translate != null));
+        const size = fit ? [model.getSizeSignalRef('width'), model.getSizeSignalRef('height')] : undefined;
+        const data = fit ? gatherFitData(model) : undefined;
+        const projComp = new ProjectionComponent(model.projectionName(true), {
+            ...replaceExprRef(model.config.projection),
+            ...proj,
+        }, size, data);
+        if (!projComp.get('type')) {
+            projComp.set('type', 'equalEarth', false);
+        }
+        return projComp;
+    }
+    return undefined;
+}
+function gatherFitData(model) {
+    const data = [];
+    const { encoding } = model;
+    for (const posssiblePair of [
+        [LONGITUDE, LATITUDE],
+        [LONGITUDE2, LATITUDE2],
+    ]) {
+        if (getFieldOrDatumDef(encoding[posssiblePair[0]]) || getFieldOrDatumDef(encoding[posssiblePair[1]])) {
+            data.push({
+                signal: model.getName(`geojson_${data.length}`),
+            });
+        }
+    }
+    if (model.channelHasField(SHAPE) && model.typedFieldDef(SHAPE).type === GEOJSON) {
+        data.push({
+            signal: model.getName(`geojson_${data.length}`),
+        });
+    }
+    if (data.length === 0) {
+        // main source is geojson, so we can just use that
+        data.push(model.requestDataName(DataSourceType.Main));
+    }
+    return data;
+}
+function mergeIfNoConflict(first, second) {
+    const allPropertiesShared = every(PROJECTION_PROPERTIES, (prop) => {
+        // neither has the property
+        if (!has$1(first.explicit, prop) && !has$1(second.explicit, prop)) {
+            return true;
+        }
+        // both have property and an equal value for property
+        if (has$1(first.explicit, prop) &&
+            has$1(second.explicit, prop) &&
+            // some properties might be signals or objects and require hashing for comparison
+            deepEqual(first.get(prop), second.get(prop))) {
+            return true;
+        }
+        return false;
+    });
+    const size = deepEqual(first.size, second.size);
+    if (size) {
+        if (allPropertiesShared) {
+            return first;
+        }
+        else if (deepEqual(first.explicit, {})) {
+            return second;
+        }
+        else if (deepEqual(second.explicit, {})) {
+            return first;
+        }
+    }
+    // if all properties don't match, let each unit spec have its own projection
+    return null;
+}
+function parseNonUnitProjections(model) {
+    if (model.children.length === 0) {
+        return undefined;
+    }
+    let nonUnitProjection;
+    // parse all children first
+    for (const child of model.children) {
+        parseProjection(child);
+    }
+    // analyze parsed projections, attempt to merge
+    const mergable = every(model.children, (child) => {
+        const projection = child.component.projection;
+        if (!projection) {
+            // child layer does not use a projection
+            return true;
+        }
+        else if (!nonUnitProjection) {
+            // cached 'projection' is null, cache this one
+            nonUnitProjection = projection;
+            return true;
+        }
+        else {
+            const merge = mergeIfNoConflict(nonUnitProjection, projection);
+            if (merge) {
+                nonUnitProjection = merge;
+            }
+            return !!merge;
+        }
+    });
+    // if cached one and all other children share the same projection,
+    if (nonUnitProjection && mergable) {
+        // so we can elevate it to the layer level
+        const name = model.projectionName(true);
+        const modelProjection = new ProjectionComponent(name, nonUnitProjection.specifiedProjection, nonUnitProjection.size, duplicate(nonUnitProjection.data));
+        // rename and assign all others as merged
+        for (const child of model.children) {
+            const projection = child.component.projection;
+            if (projection) {
+                if (projection.isFit) {
+                    modelProjection.data.push(...child.component.projection.data);
+                }
+                child.renameProjection(projection.get('name'), name);
+                projection.merged = true;
+            }
+        }
+        return modelProjection;
+    }
+    return undefined;
+}
+
 function assembleScales(model) {
     if (isLayerModel(model) || isConcatModel(model)) {
         // For concat and layer, include scales of children too
@@ -64801,6 +64939,7 @@ var vegaLiteImport = /*#__PURE__*/Object.freeze({
   isInternalField: isInternalField,
   isNullOrFalse: isNullOrFalse,
   isNumeric: isNumeric,
+  isPrimitive: isPrimitive,
   keys: keys,
   logicalExpr: logicalExpr,
   mergeDeep: mergeDeep$1,