@geode/opengeodeweb-front 10.34.0-rc.8 → 10.34.0

package/internal/stores/data_style/model/edges/common.ts

@@ -1,17 +1,25 @@
 import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 
-export function useModelEdgesCommonStyle() {
+export function useModelEdgesCommonStyle(): {
+  modelEdgesStyle: (id: string) => StyleValues;
+  mutateModelEdgesStyle: (id: string, values: StyleValues) => Promise<string>;
+} {
   const dataStyleState = useDataStyleState();
 
-  function mutateModelEdgesStyle(id: string, values: StyleValues) {
-    return dataStyleState.mutateStyle(id, {
+  async function mutateModelEdgesStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
       edges: values,
     });
+    return result;
   }
 
   function modelEdgesStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).edges as StyleValues;
+    const { edges } = dataStyleState.getStyle(id);
+    if (edges === undefined) {
+      return {};
+    }
+    return edges;
   }
 
   return {

package/internal/stores/data_style/model/edges/index.ts

@@ -1,7 +1,8 @@
 import { useModelEdgesCommonStyle } from "./common";
 import { useModelEdgesVisibilityStyle } from "./visibility";
 
-export function useModelEdgesStyle() {
+export function useModelEdgesStyle(): ReturnType<typeof useModelEdgesCommonStyle> &
+  ReturnType<typeof useModelEdgesVisibilityStyle> {
   const modelEdgesCommonStyle = useModelEdgesCommonStyle();
   const modelEdgesVisibilityStyle = useModelEdgesVisibilityStyle();
 

package/internal/stores/data_style/model/edges/visibility.ts

@@ -7,27 +7,44 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.model.edges.visibility;
 
-export function useModelEdgesVisibilityStyle() {
+interface ModelEdgesVisibilityStyleApi {
+  modelEdgesVisibility: (id: string) => boolean | undefined;
+  setModelEdgesVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+  applyModelEdgesStyle: (id: string) => Promise<unknown[]>;
+}
+
+export function useModelEdgesVisibilityStyle(): ModelEdgesVisibilityStyleApi {
   const viewerStore = useViewerStore();
   const modelEdgesCommonStyle = useModelEdgesCommonStyle();
 
   function modelEdgesVisibility(id: string): boolean | undefined {
-    return modelEdgesCommonStyle.modelEdgesStyle(id).visibility as boolean | undefined;
+    const { visibility } = modelEdgesCommonStyle.modelEdgesStyle(id);
+    if (typeof visibility === "boolean") {
+      return visibility;
+    }
+    return undefined;
   }
 
-  function setModelEdgesVisibility(id: string, visibility: boolean | undefined) {
+  async function setModelEdgesVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
     const params = { id, visibility };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       { schema, params },
       {
-        response_function: () => modelEdgesCommonStyle.mutateModelEdgesStyle(id, { visibility }),
+        response_function: async () => {
+          await modelEdgesCommonStyle.mutateModelEdgesStyle(id, { visibility });
+        },
       },
     );
+    return result;
   }
 
-  function applyModelEdgesStyle(id: string) {
+  async function applyModelEdgesStyle(id: string): Promise<unknown[]> {
     const visibility = modelEdgesVisibility(id);
-    return Promise.resolve([setModelEdgesVisibility(id, visibility)]);
+    const result = await setModelEdgesVisibility(id, visibility);
+    return [result];
   }
 
   return {

package/internal/stores/data_style/model/index.ts

@@ -1,3 +1,4 @@
+import type { ComputedRef } from "vue";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 import { useModelBlocksStyle } from "./blocks";
@@ -10,8 +11,21 @@ import { useModelSelection } from "./selection";
 import { useModelSurfacesStyle } from "./surfaces";
 import { useModelVisibilityStyle } from "./visibility";
 
+type UseModelStyleReturn = ReturnType<typeof useModelColorStyle> &
+  ReturnType<typeof useModelVisibilityStyle> &
+  ReturnType<typeof useModelBlocksStyle> &
+  ReturnType<typeof useModelCornersStyle> &
+  ReturnType<typeof useModelEdgesStyle> &
+  ReturnType<typeof useModelLinesStyle> &
+  ReturnType<typeof useModelPointsStyle> &
+  ReturnType<typeof useModelSurfacesStyle> & {
+    visibleMeshComponents: (modelId: string) => ComputedRef<string[]>;
+    applyModelStyle: (modelId: string) => Promise<unknown[]>;
+    setModelMeshComponentsDefaultStyle: (modelId: string) => Promise<unknown[]>;
+  };
+
 // oxlint-disable-next-line max-lines-per-function, max-statements
-function useModelStyle() {
+function useModelStyle(): UseModelStyleReturn {
   const dataStore = useDataStore();
   const dataStyleState = useDataStyleState();
   const modelCornersStyle = useModelCornersStyle();
@@ -31,15 +45,15 @@ function useModelStyle() {
   const modelColorStyle = useModelColorStyle(componentStyleFunctions);
   const modelVisibilityStyle = useModelVisibilityStyle(componentStyleFunctions);
 
-  function visibleMeshComponents(modelId: string) {
+  function visibleMeshComponents(modelId: string): ComputedRef<string[]> {
     return useModelSelection(modelId, dataStyleState);
   }
 
-  function applyModelStyle(modelId: string) {
+  async function applyModelStyle(modelId: string): Promise<unknown[]> {
     const style = dataStyleState.getStyle(modelId);
 
-    return Promise.all([
-      modelVisibilityStyle.setModelVisibility(modelId, style.visibility as boolean),
+    const results = await Promise.all([
+      modelVisibilityStyle.setModelVisibility(modelId, style.visibility ?? false),
       modelBlocksStyle.applyModelBlocksStyle(modelId),
       modelSurfacesStyle.applyModelSurfacesStyle(modelId),
       modelLinesStyle.applyModelLinesStyle(modelId),
@@ -47,19 +61,18 @@ function useModelStyle() {
       modelPointsStyle.applyModelPointsStyle(modelId),
       modelEdgesStyle.applyModelEdgesStyle(modelId),
     ]);
+    return results;
   }
 
-  async function setModelMeshComponentsDefaultStyle(modelId: string) {
-    const item = await dataStore.item(modelId);
-    if (!item) {
-      return;
-    }
-    return await Promise.all([
+  async function setModelMeshComponentsDefaultStyle(modelId: string): Promise<unknown[]> {
+    await dataStore.item(modelId);
+    const results = await Promise.all([
       modelBlocksStyle.setModelBlocksDefaultStyle(modelId),
       modelSurfacesStyle.setModelSurfacesDefaultStyle(modelId),
       modelLinesStyle.setModelLinesDefaultStyle(modelId),
       modelCornersStyle.setModelCornersDefaultStyle(modelId),
     ]);
+    return results;
   }
 
   return {

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

@@ -1,21 +1,39 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
 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";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.lines.color;
 
-export function useModelLinesColor() {
+export function useModelLinesColor(): {
+  setModelLinesColor: (
+    modelId: string,
+    lines_ids: string[],
+    color: unknown,
+    activeColoring?: string,
+    collectionId?: string,
+  ) => Promise<unknown>;
+  modelLineColoring: (id: string, line_id?: string) => StyleValues;
+  modelLineColor: (id: string, line_id?: string) => unknown;
+  modelLineActiveColoring: (id: string, line_id?: string) => unknown;
+  setModelLinesActiveColoring: (
+    modelId: string,
+    lines_ids: string[],
+    activeColoring: string,
+    collectionId?: string,
+  ) => Promise<unknown>;
+} {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
   const modelLinesEdgeAttribute = useModelLinesEdgeAttribute();
 
   function modelLineColoring(id: string, line_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return modelLinesCommonStyle.modelLineStyle(id, line_id).coloring as StyleValues;
   }
 
@@ -23,13 +41,22 @@ export function useModelLinesColor() {
     return modelLineColoring(id, line_id).constant;
   }
 
-  function setModelLinesColor(
+  async function setModelLinesColor(
     modelId: string,
     lines_ids: string[],
     color: unknown,
     activeColoring = "constant",
-  ) {
-    return modelCommonStyle.setModelTypeColor(modelId, lines_ids, color, schema, activeColoring);
+    collectionId?: string,
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      lines_ids,
+      color,
+      schema,
+      activeColoring,
+      collectionId,
+    );
+    return result;
   }
 
   function modelLineActiveColoring(id: string, line_id?: string): unknown {
@@ -40,9 +67,11 @@ export function useModelLinesColor() {
     modelId: string,
     lines_ids: string[],
     activeColoring: string,
-  ) {
-    if (lines_ids.length > 1) {
-      modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+    collectionId?: string,
+  ): Promise<unknown> {
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lines_ids.length === totalLineIds.length) {
+      await modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -51,7 +80,7 @@ export function useModelLinesColor() {
     });
     if (activeColoring === "constant" || activeColoring === "random") {
       const color = modelLineColor(modelId, lines_ids[0]);
-      return setModelLinesColor(modelId, lines_ids, color, activeColoring);
+      return setModelLinesColor(modelId, lines_ids, color, activeColoring, collectionId);
     }
 
     if (activeColoring === "vertex") {
@@ -89,6 +118,7 @@ export function useModelLinesColor() {
         return modelLinesEdgeAttribute.setModelLinesEdgeAttribute(modelId, lines_ids, attribute);
       }
     }
+    return undefined;
   }
 
   return {

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

@@ -3,12 +3,18 @@ import merge from "lodash/merge";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 
-export function useModelLinesCommonStyle() {
+export function useModelLinesCommonStyle(): {
+  modelLinesStyle: (id: string) => StyleValues;
+  modelLineStyle: (id: string, line_id?: string) => StyleValues;
+  modelLineColoring: (id: string, line_id?: string) => StyleValues;
+  mutateModelLinesColoring: (id: string, lines_ids: string[], values: StyleValues) => Promise<void>;
+  mutateModelLinesTypeColoring: (id: string, values: StyleValues) => Promise<void>;
+} {
   const dataStyleState = useDataStyleState();
   const modelCommonStyle = useModelCommonStyle();
 
   function modelLinesStyle(id: string): StyleValues {
-    return dataStyleState.getStyle(id).lines as StyleValues;
+    return dataStyleState.getStyle(id).lines ?? {};
   }
 
   function modelComponentTypeLinesStyle(id: string): StyleValues {
@@ -27,17 +33,22 @@ export function useModelLinesCommonStyle() {
   }
 
   function modelLineColoring(id: string, line_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
     return modelLineStyle(id, line_id).coloring as StyleValues;
   }
 
-  function mutateModelLinesColoring(id: string, lines_ids: string[], values: StyleValues) {
-    return modelCommonStyle.mutateComponentStyles(id, lines_ids, {
+  async function mutateModelLinesColoring(
+    id: string,
+    lines_ids: string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, lines_ids, {
       coloring: values,
     });
   }
 
-  function mutateModelLinesTypeColoring(id: string, values: StyleValues) {
-    return modelCommonStyle.mutateModelComponentTypeStyle(id, "Line", {
+  async function mutateModelLinesTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Line", {
       coloring: values,
     });
   }

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

@@ -1,3 +1,4 @@
+// oxlint-disable eslint/max-lines
 import { DEFAULT_NO_DATA_COLOR } from "@ogw_front/utils/default_styles/constants";
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -49,12 +50,61 @@ function isModelLinesEdgeAttributeValid({
   );
 }
 
+interface UseModelLinesEdgeAttributeReturn {
+  modelLinesEdgeAttributeName: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesEdgeAttributeItem: (modelId: string, lineId?: string) => number;
+  modelLinesEdgeAttributeRange: (
+    modelId: string,
+    lineId?: string,
+  ) => [number | undefined, number | undefined];
+  modelLinesEdgeAttributeColorMap: (modelId: string, lineId?: string) => string | undefined;
+  modelLinesEdgeAttributeStoredConfig: (
+    modelId: string,
+    lineId: string | undefined,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setModelLinesEdgeAttribute: (
+    modelId: string,
+    lineIds: string[],
+    input: AttributeInput,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeName: (
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeItem: (
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeRange: (
+    modelId: string,
+    lineIds: string[],
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setModelLinesEdgeAttributeColorMap: (
+    modelId: string,
+    lineIds: string[],
+    colorMap: string | undefined,
+  ) => Promise<unknown>;
+  modelLinesEdgeAttributeNoDataColor: (modelId: string, lineId?: string) => unknown;
+  setModelLinesEdgeAttributeNoDataColor: (
+    modelId: string,
+    lineIds: string[],
+    no_data_color: unknown,
+  ) => Promise<unknown>;
+}
+
 // oxlint-disable-next-line max-lines-per-function
-function useModelLinesEdgeAttribute() {
+function useModelLinesEdgeAttribute(): UseModelLinesEdgeAttributeReturn {
   const dataStore = useDataStore();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const viewerStore = useViewerStore();
   function modelLinesEdgeAttribute(modelId: string, lineId?: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.edge shape is defined by the data style schema.
     return modelLinesCommonStyle.modelLineColoring(modelId, lineId).edge as AttributeState;
   }
   function modelLinesEdgeAttributeStoredConfig(
@@ -64,14 +114,10 @@ function useModelLinesEdgeAttribute() {
     item: number | undefined,
   ): AttributeStoredConfig {
     const { storedConfigs } = modelLinesEdgeAttribute(modelId, lineId);
-    if (
-      storedConfigs &&
-      name !== undefined &&
-      name in storedConfigs &&
-      item !== undefined &&
-      item in storedConfigs[name]!
-    ) {
-      return storedConfigs[name]![item]!;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    const itemConfig = item === undefined ? undefined : nameConfig?.[item];
+    if (itemConfig !== undefined) {
+      return itemConfig;
     }
     return {
       minimum: undefined,
@@ -80,32 +126,41 @@ function useModelLinesEdgeAttribute() {
       no_data_color: DEFAULT_NO_DATA_COLOR,
     };
   }
-  function mutateModelLinesEdgeStyle(
+  async function mutateModelLinesEdgeStyle(
     modelId: string,
     lineIds: string[],
     values: Record<string, unknown>,
-  ) {
-    if (lineIds.length > 1) {
-      modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+  ): Promise<void> {
+    const tasks: Promise<void>[] = [
+      modelLinesCommonStyle.mutateModelLinesColoring(modelId, lineIds, {
         edge: values,
-      });
+      }),
+    ];
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lineIds.length === totalLineIds.length) {
+      tasks.push(
+        modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+          edge: values,
+        }),
+      );
     }
-    return modelLinesCommonStyle.mutateModelLinesColoring(modelId, lineIds, {
-      edge: values,
-    });
+    await Promise.all(tasks);
   }
-  function setModelLinesEdgeAttributeStoredConfig(
+  async function setModelLinesEdgeAttributeStoredConfig(
     modelId: string,
     lineIds: string[],
     name: string | undefined,
     item: number | undefined,
     config: Partial<AttributeStoredConfig>,
-  ) {
-    return mutateModelLinesEdgeStyle(modelId, lineIds, {
+  ): Promise<void> {
+    if (name === undefined || item === undefined) {
+      return;
+    }
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
       storedConfigs: {
-        [name as string]: {
+        [name]: {
           lastItem: item,
-          [item as number]: config,
+          [item]: config,
         },
       },
     });
@@ -119,8 +174,9 @@ function useModelLinesEdgeAttribute() {
     name: string | undefined,
   ): number {
     const { storedConfigs } = modelLinesEdgeAttribute(modelId, lineId);
-    if (storedConfigs && name !== undefined && name in storedConfigs) {
-      return storedConfigs[name]!.lastItem;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
     }
     return 0;
   }
@@ -157,18 +213,18 @@ function useModelLinesEdgeAttribute() {
       colorMap,
       no_data_color = DEFAULT_NO_DATA_COLOR,
     }: AttributeInput,
-  ) {
-    mutateModelLinesEdgeStyle(modelId, lineIds, {
+  ): Promise<unknown> {
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
       name,
       item,
     });
-    setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
       minimum,
       maximum,
       colorMap,
       no_data_color,
     });
-    const points = getRGBPointsFromPreset(colorMap as string);
+    const points = getRGBPointsFromPreset(colorMap ?? "");
     const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(modelId, lineIds);
     const params = {
       id: modelId,
@@ -185,7 +241,7 @@ function useModelLinesEdgeAttribute() {
       params,
     });
   }
-  function applyEdgeAttribute(modelId: string, lineIds: string[]) {
+  async function applyEdgeAttribute(modelId: string, lineIds: string[]): Promise<void> {
     const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
     const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
     const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineIds[0], name, item);
@@ -198,46 +254,53 @@ function useModelLinesEdgeAttribute() {
       no_data_color: storedConfig.no_data_color,
     };
     if (isModelLinesEdgeAttributeValid(attribute)) {
-      return setModelLinesEdgeAttribute(modelId, lineIds, attribute);
+      await setModelLinesEdgeAttribute(modelId, lineIds, attribute);
     }
-    return Promise.resolve();
   }
-  function setModelLinesEdgeAttributeName(modelId: string, lineIds: string[], name: string) {
+  async function setModelLinesEdgeAttributeName(
+    modelId: string,
+    lineIds: string[],
+    name: string,
+  ): Promise<unknown> {
     const item = modelLinesEdgeAttributeLastItem(modelId, lineIds[0], name);
-    mutateModelLinesEdgeStyle(modelId, lineIds, {
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
       name,
       item,
     });
     return applyEdgeAttribute(modelId, lineIds);
   }
-  function setModelLinesEdgeAttributeItem(modelId: string, lineIds: string[], item: number) {
-    mutateModelLinesEdgeStyle(modelId, lineIds, {
+  async function setModelLinesEdgeAttributeItem(
+    modelId: string,
+    lineIds: string[],
+    item: number,
+  ): Promise<unknown> {
+    await mutateModelLinesEdgeStyle(modelId, lineIds, {
       item,
     });
     return applyEdgeAttribute(modelId, lineIds);
   }
-  function setModelLinesEdgeAttributeRange(
+  async function setModelLinesEdgeAttributeRange(
     modelId: string,
     lineIds: string[],
     minimum: number,
     maximum: number,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
     const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
-    setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
       minimum,
       maximum,
     });
     return applyEdgeAttribute(modelId, lineIds);
   }
-  function setModelLinesEdgeAttributeColorMap(
+  async function setModelLinesEdgeAttributeColorMap(
     modelId: string,
     lineIds: string[],
     colorMap: string | undefined,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
     const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
-    setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
+    await setModelLinesEdgeAttributeStoredConfig(modelId, lineIds, name, item, {
       colorMap,
     });
     return applyEdgeAttribute(modelId, lineIds);
@@ -252,7 +315,7 @@ function useModelLinesEdgeAttribute() {
     modelId: string,
     lineIds: string[],
     no_data_color: unknown,
-  ) {
+  ): Promise<unknown> {
     const name = modelLinesEdgeAttributeName(modelId, lineIds[0]);
     const item = modelLinesEdgeAttributeItem(modelId, lineIds[0]);
     const storedConfig = modelLinesEdgeAttributeStoredConfig(modelId, lineIds[0], name, item);