@geode/opengeodeweb-front 10.34.0-rc.14 → 10.34.0-rc.16

package/app/components/Viewer/ContextMenu/InfoCard.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import GlassCard from "@ogw_front/components/GlassCard.vue";
 import { middleTruncate } from "@ogw_front/utils/string";
-import { useClipboard } from "@vueuse/core";
+import { useCopyToClipboard } from "@ogw_front/composables/copy_to_clipboard";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useMenuStore } from "@ogw_front/stores/menu";
 
@@ -17,7 +17,6 @@ const emit = defineEmits<{
   "update:show": [value: boolean];
 }>();
 
-const COPIED_TIMEOUT = 1500;
 const MAX_SHORT_ID_LENGTH = 15;
 const ID_SLICE_START = 8;
 const ID_SLICE_END_OFFSET = 7;
@@ -25,7 +24,7 @@ const TRUNCATE_MAX_LENGTH = 22;
 const TRUNCATE_START_CHARS = 12;
 const TRUNCATE_END_CHARS = 7;
 
-const { copy, copied } = useClipboard({ copiedDuring: COPIED_TIMEOUT });
+const { copy, copied } = useCopyToClipboard();
 const copiedId = ref("");
 
 function isCopied(id: string | undefined): boolean {

package/app/components/Viewer/Options/ColorPicker.vue

@@ -1,6 +1,8 @@
 <script setup lang="ts">
-// oxlint-disable id-length
+// oxlint-disable id-length since vuetify require { r,g,b} format to work
+import { formatColorString, parseColorString } from "@ogw_front/utils/color_picker";
 import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
+import { useCopyToClipboard } from "@ogw_front/composables/copy_to_clipboard";
 
 interface Props {
   disabledAlpha?: boolean;
@@ -8,12 +10,15 @@ interface Props {
 
 const { disabledAlpha = false } = defineProps<Props>();
 
-// The useMousePressed composable only needs the underlying DOM element (it unwraps a component ref's $el at runtime); typing this as the actual Vuetify component instance produces a union too complex for TS to represent.
-const colorPickerRef = useTemplateRef<HTMLElement>("colorPickerRef");
+const colorPickerWrapperRef = useTemplateRef<HTMLElement>("colorPickerWrapperRef");
+const { pressed } = useMousePressed({ target: colorPickerWrapperRef });
+
 const model = defineModel<RGBAColor>();
-const { pressed } = useMousePressed({ target: colorPickerRef });
+const { copy, copied } = useCopyToClipboard();
+
+const currentMode = ref(disabledAlpha ? "rgb" : "rgba");
+const colorInputText = ref("");
 
-// The model is always bound by every current caller (ColoringTypeSelector.vue, AttributeSelector.vue); defineModel can't express that as a required prop without breaking its optional v-model contract, so this reads it as defined here.
 const initialColor = model.value as RGBAColor;
 const vuetifyColor = ref({
   r: initialColor.red,
@@ -22,69 +27,246 @@ const vuetifyColor = ref({
   a: initialColor.alpha,
 });
 
+function updateInputTextFromColor(red: number, green: number, blue: number, alpha: number) {
+  colorInputText.value =
+    disabledAlpha || currentMode.value === "rgb"
+      ? `${red}, ${green}, ${blue}`
+      : `${red}, ${green}, ${blue}, ${alpha}`;
+}
+
+interface VuetifyColor {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+function commitColorToModel() {
+  const { r: red, g: green, b: blue, a: alpha } = vuetifyColor.value;
+  model.value = { red, green, blue, alpha };
+}
+
+function onPickerUpdate(color: VuetifyColor) {
+  const red = Math.round(color.r);
+  const green = Math.round(color.g);
+  const blue = Math.round(color.b);
+  const alpha = disabledAlpha ? 1 : Number(color.a.toFixed(2));
+
+  vuetifyColor.value = { r: red, g: green, b: blue, a: alpha };
+  updateInputTextFromColor(red, green, blue, alpha);
+  if (!pressed.value) {
+    commitColorToModel();
+  }
+}
+
+function toggleMode() {
+  if (disabledAlpha) {
+    return;
+  }
+  currentMode.value = currentMode.value === "rgba" ? "rgb" : "rgba";
+  const { r: red, g: green, b: blue, a: alpha } = vuetifyColor.value;
+  updateInputTextFromColor(red, green, blue, alpha);
+}
+
+async function copyToClipboard() {
+  const { r: red, g: green, b: blue, a: alpha } = vuetifyColor.value;
+  await copy(formatColorString({ red, green, blue, alpha }, currentMode.value));
+}
+
+function parseAndApplyText(text: string) {
+  const parsed = parseColorString(text);
+  if (!parsed) {
+    return false;
+  }
+
+  const { red, green, blue, alpha: rawAlpha } = parsed;
+  const alpha = disabledAlpha ? 1 : rawAlpha;
+
+  if (!disabledAlpha && alpha < 1) {
+    currentMode.value = "rgba";
+  }
+
+  vuetifyColor.value = { r: red, g: green, b: blue, a: alpha };
+  model.value = { red, green, blue, alpha };
+  updateInputTextFromColor(red, green, blue, alpha);
+  return true;
+}
+
+function onInputPaste(event: ClipboardEvent) {
+  event.preventDefault();
+  const text = event.clipboardData!.getData("text/plain");
+  parseAndApplyText(text);
+}
+
+function onInputCommit() {
+  if (!parseAndApplyText(colorInputText.value)) {
+    const { r: red, g: green, b: blue, a: alpha } = vuetifyColor.value;
+    updateInputTextFromColor(red, green, blue, alpha);
+  }
+}
+
 watch(
   model,
   (newValue) => {
     if (!newValue) {
       return;
     }
-    const hasChanged =
-      newValue.red !== vuetifyColor.value.r ||
-      newValue.green !== vuetifyColor.value.g ||
-      newValue.blue !== vuetifyColor.value.b ||
-      newValue.alpha !== vuetifyColor.value.a;
-    if (!hasChanged) {
-      return;
+    const { red, green, blue, alpha } = newValue;
+    if (
+      vuetifyColor.value.r !== red ||
+      vuetifyColor.value.g !== green ||
+      vuetifyColor.value.b !== blue ||
+      vuetifyColor.value.a !== alpha
+    ) {
+      vuetifyColor.value = { r: red, g: green, b: blue, a: alpha };
     }
-    vuetifyColor.value = {
-      r: newValue.red,
-      g: newValue.green,
-      b: newValue.blue,
-      a: newValue.alpha,
-    };
+    updateInputTextFromColor(red, green, blue, alpha);
   },
-  { deep: true },
+  { deep: true, immediate: true },
 );
 
-watch(pressed, (value) => {
-  if (!value) {
-    model.value = {
-      red: vuetifyColor.value.r,
-      green: vuetifyColor.value.g,
-      blue: vuetifyColor.value.b,
-      alpha: vuetifyColor.value.a,
-    };
+watch(pressed, (isPressed) => {
+  if (!isPressed) {
+    commitColorToModel();
   }
 });
+
+watch(
+  () => disabledAlpha,
+  (disabled) => {
+    if (disabled) {
+      currentMode.value = "rgb";
+      if (model.value) {
+        model.value = { ...model.value, alpha: 1 };
+      }
+    }
+  },
+);
 </script>
 
 <template>
-  <v-color-picker
-    ref="colorPickerRef"
-    data-testid="colorPicker"
-    v-model="vuetifyColor"
-    flat
-    canvas-height="75"
-    hide-inputs
-    hide-eye-dropper
-    :disabled-alpha="disabledAlpha"
-    width="220"
-    :mode="disabledAlpha ? 'rgb' : 'rgba'"
-    class="mx-auto"
-  />
+  <div
+    ref="colorPickerWrapperRef"
+    class="color-picker-wrapper mx-auto rounded-lg overflow-hidden border"
+  >
+    <v-color-picker
+      data-testid="colorPicker"
+      :model-value="vuetifyColor"
+      @update:model-value="onPickerUpdate"
+      mode="rgba"
+      flat
+      canvas-height="75"
+      hide-eye-dropper
+      hide-inputs
+      :disabled-alpha="disabledAlpha"
+      width="220"
+      class="mx-auto bg-transparent"
+    />
+
+    <div class="color-picker-controls pa-2 pt-0">
+      <div class="d-flex align-center justify-space-between px-1 mb-1">
+        <div class="d-flex align-center ga-1">
+          <span
+            class="text-caption font-weight-medium text-uppercase text-medium-emphasis"
+            style="font-size: 0.68rem"
+          >
+            {{ currentMode }}
+          </span>
+          <v-btn
+            v-if="!disabledAlpha"
+            icon
+            density="compact"
+            variant="text"
+            size="small"
+            @click="toggleMode"
+            v-tooltip="'Swap mode (RGB / RGBA)'"
+          >
+            <v-icon icon="mdi-swap-horizontal" size="16" />
+          </v-btn>
+        </div>
+
+        <v-btn
+          data-testid="copyColorBtn"
+          icon
+          density="compact"
+          variant="text"
+          size="small"
+          @click="copyToClipboard"
+          v-tooltip="'Copy to clipboard'"
+        >
+          <v-icon
+            :icon="copied ? 'mdi-check' : 'mdi-content-copy'"
+            size="14"
+            :color="copied ? 'success' : undefined"
+          />
+        </v-btn>
+      </div>
+
+      <input
+        data-testid="colorInput"
+        v-model="colorInputText"
+        class="color-input-field"
+        type="text"
+        spellcheck="false"
+        autocomplete="off"
+        @paste="onInputPaste"
+        @change="onInputCommit"
+        @keydown.enter.prevent="onInputCommit"
+      />
+    </div>
+  </div>
 </template>
 
 <style scoped>
+.color-picker-wrapper {
+  width: 220px;
+  background-color: rgba(33, 33, 33, 0.95);
+  border: 1px solid rgba(255, 255, 255, 0.12) !important;
+  outline: none;
+}
+
+:deep(.v-color-picker) {
+  background-color: transparent !important;
+  box-shadow: none !important;
+}
+
+:deep(.v-color-picker-canvas),
+:deep(.v-color-picker__preview),
+:deep(.v-color-picker__controls) {
+  box-shadow: none !important;
+}
+
 :deep(.v-color-picker__controls) {
-  padding: 8px !important;
+  padding: 4px 8px 0 !important;
 }
 
 :deep(.v-color-picker__dot) {
   width: 18px !important;
   height: 18px !important;
+  box-shadow: none !important;
 }
 
 :deep(.v-color-picker__preview) {
   margin-bottom: 0 !important;
 }
+
+.color-input-field {
+  width: 100%;
+  box-sizing: border-box;
+  padding: 6px 10px;
+  background-color: rgba(255, 255, 255, 0.08);
+  border: 1px solid transparent;
+  border-radius: 6px;
+  outline: none;
+  color: inherit;
+  font-size: 0.82rem;
+  font-family: monospace;
+  letter-spacing: 0.5px;
+  text-align: center;
+  transition: border-color 0.15s ease;
+}
+
+.color-input-field:focus {
+  border-color: rgba(255, 255, 255, 0.3);
+}
 </style>

package/app/composables/copy_to_clipboard.ts

@@ -0,0 +1,7 @@
+import { useClipboard } from "@vueuse/core";
+
+const COPIED_FEEDBACK_TIMEOUT = 1500;
+
+export function useCopyToClipboard(): ReturnType<typeof useClipboard> {
+  return useClipboard({ copiedDuring: COPIED_FEEDBACK_TIMEOUT });
+}

package/app/stores/app.ts

@@ -170,6 +170,7 @@ export const useAppStore = defineStore("app", () => {
 
   // `TResult` is asserted, not verified, at the single `return result as TResult` boundary below: the backend response is only checked against `schema` at runtime, so callers' `TResult` is a contract with the schema, not something this function can prove.
   // oxlint-disable-next-line unicorn/consistent-function-scoping
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
   async function request<TResult = unknown>(
     { schema, params }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
     callbacks: RequestHandlers = {},

package/app/utils/color_picker.js

@@ -0,0 +1,54 @@
+const RGB_MAX = 255;
+const PERCENT_MAX = 100;
+
+function parseComponent(val, max = RGB_MAX) {
+  if (val.endsWith("%")) {
+    return (Number(val.slice(0, -1)) / PERCENT_MAX) * max;
+  }
+  return Number(val);
+}
+
+function parseColorString(colorText) {
+  if (!colorText || typeof colorText !== "string") {
+    return undefined;
+  }
+
+  const numbersMatch = colorText.match(/[\d.]+%?/gu);
+  if (!numbersMatch || (numbersMatch.length !== 3 && numbersMatch.length !== 4)) {
+    return undefined;
+  }
+
+  const rawRed = parseComponent(numbersMatch[0]);
+  const rawGreen = parseComponent(numbersMatch[1]);
+  const rawBlue = parseComponent(numbersMatch[2]);
+
+  const red = Math.min(RGB_MAX, Math.max(0, Math.round(rawRed)));
+  const green = Math.min(RGB_MAX, Math.max(0, Math.round(rawGreen)));
+  const blue = Math.min(RGB_MAX, Math.max(0, Math.round(rawBlue)));
+
+  let alpha = 1;
+  if (numbersMatch.length === 4) {
+    const rawAlpha = parseComponent(numbersMatch[3], 1);
+    const calculatedAlpha = rawAlpha > 1 ? rawAlpha / RGB_MAX : rawAlpha;
+    const roundedAlpha = Number(calculatedAlpha.toFixed(2));
+    alpha = Math.min(1, Math.max(0, roundedAlpha));
+  }
+
+  if (Number.isNaN(red) || Number.isNaN(green) || Number.isNaN(blue) || Number.isNaN(alpha)) {
+    return undefined;
+  }
+
+  return { red, green, blue, alpha };
+}
+
+function formatColorString(color, mode) {
+  const { red, green, blue, alpha } = color;
+  const roundRed = Math.round(red);
+  const roundGreen = Math.round(green);
+  const roundBlue = Math.round(blue);
+  return mode === "rgb"
+    ? `rgb(${roundRed}, ${roundGreen}, ${roundBlue})`
+    : `rgba(${roundRed}, ${roundGreen}, ${roundBlue}, ${alpha})`;
+}
+
+export { parseColorString, formatColorString };

package/internal/stores/data_style/model/blocks/color.ts

@@ -4,6 +4,7 @@ import {
 } from "./polyhedron";
 import { isModelBlocksVertexAttributeValid, useModelBlocksVertexAttribute } from "./vertex";
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksCommonStyle } from "./common";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -26,6 +27,7 @@ export function useModelBlocksColor(): {
     activeColoring: string,
   ) => Promise<void>;
 } {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelBlocksCommonStyle = useModelBlocksCommonStyle();
   const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
@@ -65,7 +67,8 @@ export function useModelBlocksColor(): {
     blocks_ids: string[],
     activeColoring: string,
   ): Promise<void> {
-    if (blocks_ids.length > 1) {
+    const totalBlockIds = await dataStore.getBlocksGeodeIds(modelId);
+    if (blocks_ids.length === totalBlockIds.length) {
       await modelBlocksCommonStyle.mutateModelBlocksTypeColoring(modelId, {
         active: activeColoring,
       });

package/internal/stores/data_style/model/blocks/polyhedron.ts

@@ -137,7 +137,8 @@ function useModelBlocksPolyhedronAttribute(): UseModelBlocksPolyhedronAttributeR
         polyhedron: values,
       }),
     ];
-    if (blockIds.length > 1) {
+    const totalBlockIds = await dataStore.getBlocksGeodeIds(modelId);
+    if (blockIds.length === totalBlockIds.length) {
       tasks.push(
         modelBlocksCommonStyle.mutateModelBlocksTypeColoring(modelId, {
           polyhedron: values,

package/internal/stores/data_style/model/blocks/vertex.ts

@@ -136,7 +136,8 @@ function useModelBlocksVertexAttribute(): UseModelBlocksVertexAttributeReturn {
         vertex: values,
       }),
     ];
-    if (blockIds.length > 1) {
+    const totalBlockIds = await dataStore.getBlocksGeodeIds(modelId);
+    if (blockIds.length === totalBlockIds.length) {
       tasks.push(
         modelBlocksCommonStyle.mutateModelBlocksTypeColoring(modelId, {
           vertex: values,

package/internal/stores/data_style/model/corners/color.ts

@@ -1,5 +1,6 @@
 import { isModelCornersVertexAttributeValid, useModelCornersVertexAttribute } from "./vertex";
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelCornersCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -24,6 +25,7 @@ interface ModelCornersColorApi {
 }
 
 export function useModelCornersColor(): ModelCornersColorApi {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelCornersCommonStyle = useModelCornersCommonStyle();
   const modelCornersVertexAttribute = useModelCornersVertexAttribute();
@@ -62,7 +64,8 @@ export function useModelCornersColor(): ModelCornersColorApi {
     corners_ids: string[],
     activeColoring: string,
   ): Promise<unknown> {
-    if (corners_ids.length > 1) {
+    const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
+    if (corners_ids.length === totalCornerIds.length) {
       await modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, {
         active: activeColoring,
       });

package/internal/stores/data_style/model/corners/vertex.ts

@@ -122,7 +122,8 @@ function useModelCornersVertexAttribute(): ModelCornersVertexAttributeApi {
         vertex: values,
       }),
     ];
-    if (cornerIds.length > 1) {
+    const totalCornerIds = await dataStore.getCornersGeodeIds(modelId);
+    if (cornerIds.length === totalCornerIds.length) {
       tasks.push(
         modelCornersCommonStyle.mutateModelCornersTypeColoring(modelId, { vertex: values }),
       );

package/internal/stores/data_style/model/lines/color.ts

@@ -1,6 +1,7 @@
 import { isModelLinesEdgeAttributeValid, useModelLinesEdgeAttribute } from "./edge";
 import { isModelLinesVertexAttributeValid, useModelLinesVertexAttribute } from "./vertex";
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelLinesCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -23,6 +24,7 @@ export function useModelLinesColor(): {
     activeColoring: string,
   ) => Promise<unknown>;
 } {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
@@ -62,7 +64,8 @@ export function useModelLinesColor(): {
     lines_ids: string[],
     activeColoring: string,
   ): Promise<unknown> {
-    if (lines_ids.length > 1) {
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lines_ids.length === totalLineIds.length) {
       await modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
         active: activeColoring,
       });

package/internal/stores/data_style/model/lines/edge.ts

@@ -136,7 +136,8 @@ function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
         edge: values,
       }),
     ];
-    if (lineIds.length > 1) {
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lineIds.length === totalLineIds.length) {
       tasks.push(
         modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
           edge: values,

package/internal/stores/data_style/model/lines/vertex.ts

@@ -136,7 +136,8 @@ function useModelLinesVertexAttribute(): UseModelLinesVertexAttributeReturn {
         vertex: values,
       }),
     ];
-    if (lineIds.length > 1) {
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lineIds.length === totalLineIds.length) {
       tasks.push(
         modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
           vertex: values,

package/internal/stores/data_style/model/surfaces/color.ts

@@ -1,6 +1,7 @@
 import { isModelSurfacesPolygonAttributeValid, useModelSurfacesPolygonAttribute } from "./polygon";
 import { isModelSurfacesVertexAttributeValid, useModelSurfacesVertexAttribute } from "./vertex";
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelSurfacesCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -23,6 +24,7 @@ export function useModelSurfacesColor(): {
     activeColoring: string,
   ) => Promise<unknown>;
 } {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelSurfacesCommonStyle = useModelSurfacesCommonStyle();
   const modelSurfacesVertexAttribute = useModelSurfacesVertexAttribute();
@@ -62,7 +64,8 @@ export function useModelSurfacesColor(): {
     surfaces_ids: string[],
     activeColoring: string,
   ): Promise<unknown> {
-    if (surfaces_ids.length > 1) {
+    const totalSurfaceIds = await dataStore.getSurfacesGeodeIds(modelId);
+    if (surfaces_ids.length === totalSurfaceIds.length) {
       await modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, {
         active: activeColoring,
       });

package/internal/stores/data_style/model/surfaces/polygon.ts

@@ -143,7 +143,8 @@ function useModelSurfacesPolygonAttribute(): UseModelSurfacesPolygonAttributeRet
         polygon: values,
       }),
     ];
-    if (surfaceIds.length > 1) {
+    const totalSurfaceIds = await dataStore.getSurfacesGeodeIds(modelId);
+    if (surfaceIds.length === totalSurfaceIds.length) {
       tasks.push(
         modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, { polygon: values }),
       );

package/internal/stores/data_style/model/surfaces/vertex.ts

@@ -140,7 +140,8 @@ function useModelSurfacesVertexAttribute(): UseModelSurfacesVertexAttributeRetur
         vertex: values,
       }),
     ];
-    if (surfaceIds.length > 1) {
+    const totalSurfaceIds = await dataStore.getSurfacesGeodeIds(modelId);
+    if (surfaceIds.length === totalSurfaceIds.length) {
       tasks.push(
         modelSurfacesCommonStyle.mutateModelSurfacesTypeColoring(modelId, { vertex: values }),
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.34.0-rc.14",
+  "version": "10.34.0-rc.16",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {