Remove hasParameterValue (#33223)

frontend/src/metabase-lib/parameters/utils/mbql.js

@@ -17,7 +17,6 @@ import {
   deriveFieldOperatorFromParameter,
   getParameterOperatorName,
 } from "metabase-lib/parameters/utils/operators";
-import { hasParameterValue } from "metabase-lib/parameters/utils/parameter-values";
 
 const withTemporalUnit = (fieldRef, unit) => {
   const dimension =
@@ -169,7 +168,7 @@ export function numberParameterValueToMBQL(parameter, fieldRef) {
 
 function isFieldFilterParameterConveratableToMBQL(parameter) {
   const { value, target } = parameter;
-  const hasValue = hasParameterValue(value);
+  const hasValue = value != null;
   const hasWellFormedTarget = Array.isArray(target?.[1]);
   const hasFieldDimensionTarget =
     isDimensionTarget(target) && !isTemplateTagReference(target[1]);

frontend/src/metabase-lib/parameters/utils/parameter-values.js

@@ -23,10 +23,6 @@ export function hasDefaultParameterValue(parameter) {
   return parameter.default != null;
 }
 
-export function hasParameterValue(value) {
-  return value != null;
-}
-
 export function normalizeParameter(parameter) {
   return {
     id: parameter.id,
@@ -64,13 +60,13 @@ export function normalizeParameterValue(type, value) {
 }
 
 function removeNilValuedPairs(pairs) {
-  return pairs.filter(([, value]) => hasParameterValue(value));
+  return pairs.filter(([, value]) => value != null);
 }
 
 function removeUndefaultedNilValuedPairs(pairs) {
   return pairs.filter(
     ([parameter, value]) =>
-      hasDefaultParameterValue(parameter) || hasParameterValue(value),
+      hasDefaultParameterValue(parameter) || value != null,
   );
 }
 
@@ -86,9 +82,7 @@ export function getParameterValuesBySlug(
   parameterValuesById = parameterValuesById || {};
   const parameterValuePairs = parameters.map(parameter => [
     parameter,
-    hasParameterValue(parameter.value)
-      ? parameter.value
-      : parameterValuesById[parameter.id],
+    parameter.value ?? parameterValuesById[parameter.id],
   ]);
 
   const transformedPairs = preserveDefaultedParameters

frontend/src/metabase-lib/parameters/utils/template-tags.ts

@@ -9,7 +9,6 @@ import {
 } from "metabase-types/api";
 import type { ParameterWithTarget } from "metabase-lib/parameters/types";
 import { getTemplateTagFromTarget } from "metabase-lib/parameters/utils/targets";
-import { hasParameterValue } from "metabase-lib/parameters/utils/parameter-values";
 
 function getTemplateTagType(tag: TemplateTag) {
   const { type } = tag;
@@ -124,7 +123,7 @@ export function remapParameterValuesToTemplateTags(
       const templateTagParameter = templateTagParametersByName[tag];
       const parameterValue =
         parameterValuesByDashboardParameterId[dashboardParameter.id];
-      if (hasParameterValue(parameterValue)) {
+      if (parameterValue != null) {
         parameterValues[templateTagParameter.name] = parameterValue;
       }
     }

frontend/src/metabase/lib/pulse.ts

@@ -12,7 +12,6 @@ import {
 import { isNotNull } from "metabase/core/utils/types";
 import {
   hasDefaultParameterValue,
-  hasParameterValue,
   normalizeParameterValue,
 } from "metabase-lib/parameters/utils/parameter-values";
 
@@ -217,9 +216,7 @@ export function getActivePulseParameters(
 
       return {
         ...parameter,
-        value: hasParameterValue(pulseParameter?.value)
-          ? pulseParameter.value
-          : parameter.default,
+        value: pulseParameter?.value ?? parameter.default,
       };
     })
     .filter(isNotNull);

frontend/src/metabase/parameters/utils/parameter-values.js

 import { getParameterType } from "metabase-lib/parameters/utils/parameter-type";
-import { hasParameterValue } from "metabase-lib/parameters/utils/parameter-values";
 
 export function getParameterValueFromQueryParams(parameter, queryParams) {
   queryParams = queryParams || {};
@@ -9,11 +8,11 @@ export function getParameterValueFromQueryParams(parameter, queryParams) {
   // skip parsing "" because it indicates a forcefully unset parameter
   if (maybeParameterValue === "") {
     return "";
-  } else if (hasParameterValue(maybeParameterValue)) {
+  } else if (maybeParameterValue == null) {
+    return parameter.default;
+  } else {
     const parsedValue = parseParameterValue(maybeParameterValue, parameter);
     return normalizeParameterValueForWidget(parsedValue, parameter);
-  } else {
-    return parameter.default;
   }
 }
 
@@ -90,7 +89,7 @@ function normalizeParameterValueForWidget(value, parameter) {
 function removeAllEmptyStringParameters(pairs) {
   return pairs
     .map(([parameter, value]) => [parameter, value === "" ? undefined : value])
-    .filter(([parameter, value]) => hasParameterValue(value));
+    .filter(([parameter, value]) => value != null);
 }
 
 function removeUndefaultedEmptyStringParameters(pairs) {
@@ -99,7 +98,7 @@ function removeUndefaultedEmptyStringParameters(pairs) {
       parameter,
       value === "" ? parameter.default : value,
     ])
-    .filter(([, value]) => hasParameterValue(value));
+    .filter(([, value]) => value != null);
 }
 
 // when `forcefullyUnsetDefaultedParametersWithEmptyStringValue` is true, we treat defaulted parameters with an empty string value as explecitly unset.