@vuu-ui/vuu-data-editing 4.0.0-alpha.10 → 4.0.0-alpha.12

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.12",
   "description": "Shared data editing APIs and React components for VUU UI",
   "main": "./src/index.js",
   "author": "heswell",
@@ -12,13 +12,13 @@
   },
   "dependencies": {
     "@salt-ds/core": "1.67.0",
-    "@vuu-ui/vuu-ui-controls": "4.0.0-alpha.10",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.10"
+    "@vuu-ui/vuu-ui-controls": "4.0.0-alpha.12",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.12"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.10",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.10",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.10"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.12",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.12",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.12"
   },
   "peerDependencies": {
     "react": "^19.2.3"

package/src/EditModeProvider.js

@@ -1,11 +1,16 @@
 import { jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState } from "react";
+import { createContext, useContext, useEffect, useState } from "react";
 const EditModeContext = /*#__PURE__*/ createContext({
     isEditMode: false,
     setEditMode: ()=>"EditModeProvider in place"
 });
-const EditModeProvider = ({ children })=>{
-    const [isEditMode, setEditMode] = useState(false);
+const EditModeProvider = ({ children, isEditMode: isEditModeProp = false })=>{
+    const [isEditMode, setEditMode] = useState(isEditModeProp);
+    useEffect(()=>{
+        setEditMode(isEditModeProp);
+    }, [
+        isEditModeProp
+    ]);
     return /*#__PURE__*/ jsx(EditModeContext.Provider, {
         value: {
             isEditMode,

package/src/edit-field/EditField.css.js

@@ -0,0 +1,13 @@
+const css = `
+.vuuEditField {
+  & .saltDropdown {
+    --vuu-icon-height: 15px;
+    --vuu-icon-left: calc(100% - var(--salt-spacing-300));
+    --vuu-icon-size: 8px;
+    --vuu-icon-top: -3px;
+  }
+}
+
+
+`;
+export default css;

package/src/edit-field/EditField.js

@@ -1,13 +1,20 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { Checkbox, FormField, FormFieldLabel, Input } from "@salt-ds/core";
+import { Checkbox, Dropdown, FormField, FormFieldLabel, Input, Option } from "@salt-ds/core";
 import { useCallback } from "react";
 import { useEditField } from "./useEditField.js";
 import { useEditSession } from "../DataEditingProvider.js";
-import { dataDescriptorTypeToVuuRowDataItemType } from "@vuu-ui/vuu-utils";
+import { dataDescriptorTypeToVuuRowDataItemType } from "@vuu-ui/vuu-utils/src/data-utils";
 import { useEditMode } from "../EditModeProvider.js";
-const EditField = ({ dataRow, label, name, readOnly = false, required, type })=>{
+import { useLookupValues } from "../lookup-values/useLookupValues.js";
+import "./EditField.css";
+const classBase = "vuuEditField";
+const EditField = ({ dataRow, deferNewRow = false, label, name, readOnly = false, required, type, ...options })=>{
     const editSession = useEditSession();
     const { isEditMode } = useEditMode();
+    const lookupValues = useLookupValues({
+        enabled: "dropdown" === type,
+        ...options
+    });
     const onEdit = useCallback(async (editState, editPhase)=>{
         const { isValid = true, previousValue = "", value } = editState;
         if ("commit" === editPhase && editSession) {
@@ -18,7 +25,7 @@ const EditField = ({ dataRow, label, name, readOnly = false, required, type })=>
                     type: "ERROR_RESULT"
                 };
                 editSession.setNewRowValue(name, value);
-                if (editSession.isNewRowFinalColumn(name) || editSession.isNewRowComplete()) return editSession.addNewRow();
+                if (!deferNewRow && (editSession.isNewRowFinalColumn(name) || editSession.isNewRowComplete())) return editSession.addNewRow();
                 return {
                     data: void 0,
                     type: "SUCCESS_RESULT"
@@ -26,8 +33,16 @@ const EditField = ({ dataRow, label, name, readOnly = false, required, type })=>
             }
             return editSession.commit(dataRow.key, name, previousValue, value, isValid);
         }
+        if ("change" === editPhase && deferNewRow && editSession?.isNewRow(dataRow.key)) {
+            editSession.setNewRowValue(name, value);
+            return {
+                data: void 0,
+                type: "SUCCESS_RESULT"
+            };
+        }
     }, [
         dataRow,
+        deferNewRow,
         editSession,
         name
     ]);
@@ -41,14 +56,15 @@ const EditField = ({ dataRow, label, name, readOnly = false, required, type })=>
         name,
         serverDataType: "string"
     };
-    const { editing, inputProps, warningMessage, previousValue = "", ...editProps } = useEditField({
+    const { editing, inputProps, onDropdownSelectionChange, onKeyDown, previousValue = "", value, warningMessage, ...editProps } = useEditField({
         column,
-        textType: "checkbox" !== type ? type : void 0,
+        textType: "checkbox" !== type && "dropdown" !== type ? type : void 0,
         onEdit,
         type: dataDescriptorTypeToVuuRowDataItemType(column),
         value: dataValue
     });
     return /*#__PURE__*/ jsxs(FormField, {
+        className: classBase,
         "data-field": name,
         necessity: necessity,
         children: [
@@ -64,10 +80,21 @@ const EditField = ({ dataRow, label, name, readOnly = false, required, type })=>
             }) : "checkbox" === type ? /*#__PURE__*/ jsx(Checkbox, {
                 checked: Boolean(dataValue),
                 onChange: onCommit
+            }) : "dropdown" === type ? /*#__PURE__*/ jsx(Dropdown, {
+                "data-icon": "triangle-down",
+                onSelectionChange: onDropdownSelectionChange,
+                placeholder: "Please select value",
+                value: value,
+                children: lookupValues.map((listOption)=>/*#__PURE__*/ jsx(Option, {
+                        value: listOption,
+                        children: listOption.label
+                    }, listOption.value))
             }) : /*#__PURE__*/ jsx(Input, {
                 ...editProps,
                 bordered: true,
-                readOnly: readOnly
+                onKeyDown: onKeyDown,
+                readOnly: readOnly,
+                value: value
             })
         ]
     });

package/src/edit-field/useEditField.js

@@ -22,8 +22,7 @@ const useEditField = ({ column, value, onEdit, textType, type = "string" })=>{
     }, [
         value
     ]);
-    const commit = useCallback(async ()=>{
-        const { value } = editState;
+    const commit = useCallback(async (value = editState.value)=>{
         const result = column.clientSideEditValidationCheck?.(value, "*");
         if (result?.ok === false) setEditState((state)=>({
                 ...state,
@@ -42,9 +41,9 @@ const useEditField = ({ column, value, onEdit, textType, type = "string" })=>{
                 }, "commit");
                 if (isRpcSuccess(response)) {
                     isDirtyRef.current = false;
-                    setEditState(({ previousValue, value })=>({
+                    setEditState((state)=>({
                             editing: false,
-                            previousValue: previousValue === value ? void 0 : void 0 === previousValue ? initialValue : previousValue,
+                            previousValue: state.previousValue === value ? void 0 : void 0 === state.previousValue ? initialValue : state.previousValue,
                             value
                         }));
                 } else if (isRpcError(response)) {
@@ -186,6 +185,26 @@ const useEditField = ({ column, value, onEdit, textType, type = "string" })=>{
         column,
         onEdit
     ]);
+    const handleDropdownSelectionChange = useCallback((_evt, [selectedOption])=>{
+        if (!selectedOption) return;
+        const value = String(selectedOption.value);
+        isDirtyRef.current = value !== initialValueRef.current;
+        setEditState((state)=>({
+                ...state,
+                editing: true,
+                message: void 0,
+                value
+            }));
+        commit(value).then((committed)=>{
+            if (committed) setEditState((state)=>({
+                    ...state,
+                    editing: false,
+                    value
+                }));
+        });
+    }, [
+        commit
+    ]);
     return {
         editing: editState.editing,
         inputProps: {
@@ -193,11 +212,12 @@ const useEditField = ({ column, value, onEdit, textType, type = "string" })=>{
             onFocus: handleFocus,
             type: textType
         },
-        onChange: handleChange,
         onKeyDown: handleKeyDown,
         previousValue: editState.previousValue,
         value: editState.value,
-        warningMessage: editState.message
+        warningMessage: editState.message,
+        onChange: handleChange,
+        onDropdownSelectionChange: handleDropdownSelectionChange
     };
 };
 export { useEditField };

package/src/index.js

@@ -2,6 +2,7 @@ export { StaleUpdateError } from "@vuu-ui/vuu-utils";
 export { DataEditingProvider, useEditSession } from "./DataEditingProvider.js";
 export { EditField } from "./edit-field/EditField.js";
 export { useEditField } from "./edit-field/useEditField.js";
+export { lookupOptionsFromRows, useLookupValues } from "./lookup-values/useLookupValues.js";
 export { getVuuEditMessage, isEditRowReadOnly, isInlineEditingSession, withDataRowEditErrors } from "./edit-utils.js";
 export { EDIT_ACTION_ROW_CLASS_NAME_GENERATOR, editActionRowClassNameGenerator } from "./editActionRowClassNameGenerator.js";
 export { EditButtons } from "./EditButtons.js";

package/src/lookup-values/useLookupValues.js

@@ -0,0 +1,78 @@
+import { Range, useData } from "@vuu-ui/vuu-utils";
+import { useEffect, useMemo, useState } from "react";
+const DATA_ROW_COLUMN_OFFSET = 10;
+const lookupOptionsFromRows = (columns, rows, optionMap)=>{
+    const requestedColumns = [
+        optionMap.value,
+        optionMap.label,
+        ...optionMap.additionalFields ?? []
+    ];
+    const missingColumns = requestedColumns.filter((column)=>!columns.includes(column));
+    if (missingColumns.length > 0) throw Error(`[useLookupValues] lookup columns not found: ${requestedColumns.join(", ")}`);
+    return rows.map((row)=>{
+        const metadata = Object.fromEntries((optionMap.additionalFields ?? []).map((field)=>[
+                field,
+                String(row[columns.indexOf(field) + DATA_ROW_COLUMN_OFFSET])
+            ]));
+        return {
+            value: String(row[columns.indexOf(optionMap.value) + DATA_ROW_COLUMN_OFFSET]),
+            label: String(row[columns.indexOf(optionMap.label) + DATA_ROW_COLUMN_OFFSET]),
+            ...Object.keys(metadata).length > 0 ? {
+                metadata
+            } : {}
+        };
+    });
+};
+const useLookupValues = ({ enabled, optionMap, table })=>{
+    if (enabled && (void 0 === optionMap || void 0 === table)) throw Error("[useLookupValues] optionsMap and Table must be provided");
+    const { VuuDataSource } = useData();
+    const [options, setOptions] = useState([]);
+    const lookupColumns = useMemo(()=>optionMap ? [
+            optionMap.value,
+            optionMap.label,
+            ...optionMap.additionalFields ?? []
+        ] : [], [
+        optionMap
+    ]);
+    const dataSource = useMemo(()=>enabled && optionMap && table ? new VuuDataSource({
+            columns: lookupColumns,
+            table
+        }) : void 0, [
+        VuuDataSource,
+        enabled,
+        lookupColumns,
+        optionMap,
+        table
+    ]);
+    useEffect(()=>{
+        setOptions([]);
+        if (!dataSource || !optionMap) return;
+        let active = true;
+        let columns;
+        const subscribe = (message)=>{
+            if (!active) return;
+            if ("subscribed" === message.type) {
+                const schemaColumns = new Set(message.tableSchema.columns.map(({ name })=>name));
+                if (!lookupColumns.every((column)=>message.columns.includes(column) && schemaColumns.has(column))) throw Error(`[useLookupValues] lookup columns not found: ${lookupColumns.join(", ")}`);
+                columns = message.columns;
+            } else if ("viewport-update" === message.type && columns) setOptions(lookupOptionsFromRows(columns, message.rows ?? [], optionMap));
+            else if ("subscribe-failed" === message.type) console.error(`Lookup table ${table?.table} subscription failed: ${message.msg}`);
+        };
+        dataSource.subscribe({
+            range: Range(0, 100)
+        }, subscribe).catch((cause)=>{
+            if (active) console.error("Role client dropdown subscription failed:", cause);
+        });
+        return ()=>{
+            active = false;
+            dataSource.unsubscribe();
+        };
+    }, [
+        dataSource,
+        lookupColumns,
+        optionMap,
+        table
+    ]);
+    return options;
+};
+export { lookupOptionsFromRows, useLookupValues };

package/types/EditModeProvider.d.ts

@@ -7,7 +7,8 @@ export interface EditModeContextProps {
  * Implemented as a standalone Provider so that EditMode cna be implemented
  * at higher level than individual edit controls.
  */
-export declare const EditModeProvider: ({ children }: {
+export declare const EditModeProvider: ({ children, isEditMode: isEditModeProp, }: {
     children: ReactNode;
+    isEditMode?: boolean;
 }) => import("react").JSX.Element;
 export declare const useEditMode: () => EditModeContextProps;

package/types/edit-field/EditField.d.ts

@@ -1,12 +1,21 @@
 import type { DataRow } from "@vuu-ui/vuu-table-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { type OptionMap } from "../lookup-values/useLookupValues";
+import "./EditField.css";
 export type TextFieldType = "email" | "password";
-export type EditFieldType = "checkbox" | TextFieldType;
+export type EditFieldType = "checkbox" | "dropdown" | TextFieldType;
 export interface EditFieldProps {
     dataRow: DataRow;
+    deferNewRow?: boolean;
     label: string;
     name: string;
     readOnly?: boolean;
     required?: boolean;
     type?: EditFieldType;
 }
-export declare const EditField: ({ dataRow, label, name, readOnly, required, type, }: EditFieldProps) => import("react").JSX.Element;
+export interface DropdownEditFieldProps extends EditFieldProps {
+    type: "dropdown";
+    optionMap: OptionMap;
+    table: VuuTable;
+}
+export declare const EditField: ({ dataRow, deferNewRow, label, name, readOnly, required, type, ...options }: EditFieldProps | DropdownEditFieldProps) => import("react").JSX.Element;

package/types/edit-field/useEditField.d.ts

@@ -1,6 +1,7 @@
 import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 import type { RuntimeColumnDescriptor, TableCellEditHandler } from "@vuu-ui/vuu-table-types";
-import { type ChangeEventHandler, type FocusEventHandler, type KeyboardEvent } from "react";
+import { type ChangeEventHandler, type FocusEventHandler, type KeyboardEvent, type SyntheticEvent } from "react";
+import type { LookupOption } from "../lookup-values/useLookupValues";
 import type { TextFieldType } from "./EditField";
 export interface EditFieldHookProps<T extends VuuRowDataItemType = VuuRowDataItemType> {
     column: Pick<RuntimeColumnDescriptor, "clientSideEditValidationCheck" | "label" | "name">;
@@ -16,9 +17,10 @@ export declare const useEditField: <T extends string | number | boolean = string
         onFocus: FocusEventHandler<HTMLElement>;
         type: TextFieldType | undefined;
     };
-    onChange: ChangeEventHandler;
     onKeyDown: (evt: KeyboardEvent<HTMLElement>) => Promise<void>;
     previousValue: string | undefined;
     value: string;
     warningMessage: string | undefined;
+    onChange: ChangeEventHandler;
+    onDropdownSelectionChange: (_evt: SyntheticEvent, [selectedOption]: LookupOption[]) => void;
 };

package/types/index.d.ts

@@ -2,6 +2,7 @@ export { StaleUpdateError } from "@vuu-ui/vuu-utils";
 export { DataEditingProvider, useEditSession } from "./DataEditingProvider";
 export { EditField } from './edit-field/EditField';
 export { useEditField } from './edit-field/useEditField';
+export { lookupOptionsFromRows, useLookupValues, type LookupOption, type LookupValuedHookProps, type OptionMap, } from "./lookup-values/useLookupValues";
 export { getVuuEditMessage, isEditRowReadOnly, isInlineEditingSession, withDataRowEditErrors } from "./edit-utils";
 export { EDIT_ACTION_ROW_CLASS_NAME_GENERATOR, editActionRowClassNameGenerator } from "./editActionRowClassNameGenerator";
 export { EditButtons, type EditButtonProps } from "./EditButtons";

package/types/lookup-values/useLookupValues.d.ts

@@ -0,0 +1,19 @@
+import type { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type LookupOption = {
+    label: string;
+    metadata?: Record<string, string>;
+    value: number | string;
+};
+export type OptionMap = {
+    additionalFields?: readonly string[];
+    label: string;
+    value: string;
+};
+export interface LookupValuedHookProps {
+    enabled: boolean;
+    optionMap?: OptionMap;
+    table?: VuuTable;
+}
+export declare const lookupOptionsFromRows: (columns: string[], rows: DataSourceRow[], optionMap: OptionMap) => LookupOption[];
+export declare const useLookupValues: ({ enabled, optionMap, table, }: LookupValuedHookProps) => LookupOption[];