@uniformdev/canvas-react 19.173.0 → 19.173.2-alpha.210

package/dist/index.d.ts

@@ -110,36 +110,64 @@ declare const useUniformContextualEditing: ({ initialCompositionValue, enhance,
                 connectedData?: {
                     pointer: string;
                     syntax: "jptr";
-                    failureAction?: "a" | "p" | "t" | "c" | undefined;
-                    failureLogLevel?: "i" | "e" | "w" | undefined;
-                    failureDefault?: string | undefined;
-                } | undefined;
+                    failureAction?: "t" | "p" | "c" | "a";
+                    failureLogLevel?: "e" | "w" | "i";
+                    failureDefault?: string;
+                };
                 locales?: {
                     [key: string]: unknown;
-                } | undefined;
+                };
+                conditions?: {
+                    when: {
+                        op?: "&" | "|";
+                        clauses: ({
+                            rule: string;
+                            source?: string;
+                            op: string;
+                            value: string | string[];
+                        } | any)[];
+                    };
+                    value: unknown;
+                    id: number;
+                }[];
+                localesConditions?: {
+                    [key: string]: {
+                        when: {
+                            op?: "&" | "|";
+                            clauses: ({
+                                rule: string;
+                                source?: string;
+                                op: string;
+                                value: string | string[];
+                            } | any)[];
+                        };
+                        value: unknown;
+                        id: number;
+                    }[];
+                };
             };
-        } | undefined;
-        variant?: string | undefined;
+        };
+        variant?: string;
         projectMapNodes?: {
             id: string;
             path: string;
             projectMapId: string;
             data?: {
-                isSearchHit?: boolean | undefined;
+                isSearchHit?: boolean;
                 queryStrings?: {
                     name: string;
-                    value?: string | undefined;
-                    helpText?: string | undefined;
-                }[] | undefined;
-                previewValue?: string | undefined;
-            } | undefined;
+                    value?: string;
+                    helpText?: string;
+                }[];
+                previewValue?: string;
+            };
             locales?: {
                 [key: string]: {
                     path: string;
                     inherited: boolean;
                 };
-            } | undefined;
-        }[] | undefined;
+            };
+        }[];
         slots?: {
             [key: string]: {
                 type: string;
@@ -150,44 +178,74 @@ declare const useUniformContextualEditing: ({ initialCompositionValue, enhance,
                         connectedData?: {
                             pointer: string;
                             syntax: "jptr";
-                            failureAction?: "a" | "p" | "t" | "c" | undefined;
-                            failureLogLevel?: "i" | "e" | "w" | undefined;
-                            failureDefault?: string | undefined;
-                        } | undefined;
+                            failureAction?: "t" | "p" | "c" | "a";
+                            failureLogLevel?: "e" | "w" | "i";
+                            failureDefault?: string;
+                        };
                         locales?: {
                             [key: string]: unknown;
-                        } | undefined;
+                        };
+                        conditions?: {
+                            when: {
+                                op?: "&" | "|";
+                                clauses: ({
+                                    rule: string;
+                                    source?: string;
+                                    op: string;
+                                    value: string | string[];
+                                } | any)[];
+                            };
+                            value: unknown;
+                            id: number;
+                        }[];
+                        localesConditions?: {
+                            [key: string]: {
+                                when: {
+                                    op?: "&" | "|";
+                                    clauses: ({
+                                        rule: string;
+                                        source?: string;
+                                        op: string;
+                                        value: string | string[];
+                                    } | any)[];
+                                };
+                                value: unknown;
+                                id: number;
+                            }[];
+                        };
                     };
-                } | undefined;
-                variant?: string | undefined;
+                };
+                variant?: string;
                 slots?: {
                     [key: string]: any[];
-                } | undefined;
-                _id?: string | undefined;
-                _pattern?: string | undefined;
+                };
+                _id?: string;
+                _pattern?: string;
                 _dataResources?: {
                     [key: string]: {
                         type: string;
-                        isPatternParameter?: boolean | undefined;
-                        ignorePatternParameterDefault?: boolean | undefined;
-                        optionalPatternParameter?: boolean | undefined;
+                        isPatternParameter?: boolean;
+                        ignorePatternParameterDefault?: boolean;
+                        optionalPatternParameter?: boolean;
+                        dataSourceVariant?: "unpublished";
                         variables?: {
                             [key: string]: string;
-                        } | undefined;
+                        };
                     };
-                } | undefined;
+                };
                 _patternDataResources?: {
                     [key: string]: {
                         type: string;
-                        isPatternParameter?: boolean | undefined;
-                        ignorePatternParameterDefault?: boolean | undefined;
-                        optionalPatternParameter?: boolean | undefined;
+                        isPatternParameter?: boolean;
+                        ignorePatternParameterDefault?: boolean;
+                        optionalPatternParameter?: boolean;
+                        dataSourceVariant?: "unpublished";
                         variables?: {
                             [key: string]: string;
-                        } | undefined;
+                        };
                     };
-                } | undefined;
-                _patternError?: "NOTFOUND" | "CYCLIC" | undefined;
+                };
+                _patternError?: "NOTFOUND" | "CYCLIC";
                 _overrides?: {
                     [key: string]: {
                         parameters?: {
@@ -197,62 +255,92 @@ declare const useUniformContextualEditing: ({ initialCompositionValue, enhance,
                                 connectedData?: {
                                     pointer: string;
                                     syntax: "jptr";
-                                    failureAction?: "a" | "p" | "t" | "c" | undefined;
-                                    failureLogLevel?: "i" | "e" | "w" | undefined;
-                                    failureDefault?: string | undefined;
-                                } | undefined;
+                                    failureAction?: "t" | "p" | "c" | "a";
+                                    failureLogLevel?: "e" | "w" | "i";
+                                    failureDefault?: string;
+                                };
                                 locales?: {
                                     [key: string]: unknown;
-                                } | undefined;
+                                };
+                                conditions?: {
+                                    when: {
+                                        op?: "&" | "|";
+                                        clauses: ({
+                                            rule: string;
+                                            source?: string;
+                                            op: string;
+                                            value: string | string[];
+                                        } | any)[];
+                                    };
+                                    value: unknown;
+                                    id: number;
+                                }[];
+                                localesConditions?: {
+                                    [key: string]: {
+                                        when: {
+                                            op?: "&" | "|";
+                                            clauses: ({
+                                                rule: string;
+                                                source?: string;
+                                                op: string;
+                                                value: string | string[];
+                                            } | any)[];
+                                        };
+                                        value: unknown;
+                                        id: number;
+                                    }[];
+                                };
                             };
-                        } | undefined;
+                        };
                         slots?: {
                             [key: string]: any[];
-                        } | undefined;
-                        variant?: string | undefined;
+                        };
+                        variant?: string;
                     };
-                } | undefined;
+                };
                 _overridability?: {
                     parameters?: {
                         [key: string]: "yes" | "no";
-                    } | undefined;
-                    variants?: boolean | undefined;
-                    hideLockedParameters?: boolean | undefined;
-                } | undefined;
-                _locales?: string[] | undefined;
+                    };
+                    variants?: boolean;
+                    hideLockedParameters?: boolean;
+                };
+                _locales?: string[];
             }[];
-        } | undefined;
+        };
         _id: string;
-        _slug?: string | null | undefined;
+        _slug?: string | null;
         _name: string;
-        _author?: string | undefined;
-        _authorSubject?: string | undefined;
-        _creator?: string | undefined;
-        _creatorSubject?: string | undefined;
-        _pattern?: string | undefined;
+        _author?: string;
+        _authorSubject?: string;
+        _creator?: string;
+        _creatorSubject?: string;
+        _pattern?: string;
         _patternDataResources?: {
             [key: string]: {
                 type: string;
-                isPatternParameter?: boolean | undefined;
-                ignorePatternParameterDefault?: boolean | undefined;
-                optionalPatternParameter?: boolean | undefined;
+                isPatternParameter?: boolean;
+                ignorePatternParameterDefault?: boolean;
+                optionalPatternParameter?: boolean;
+                dataSourceVariant?: "unpublished";
                 variables?: {
                     [key: string]: string;
-                } | undefined;
+                };
             };
-        } | undefined;
+        };
         _dataResources?: {
             [key: string]: {
                 type: string;
-                isPatternParameter?: boolean | undefined;
-                ignorePatternParameterDefault?: boolean | undefined;
-                optionalPatternParameter?: boolean | undefined;
+                isPatternParameter?: boolean;
+                ignorePatternParameterDefault?: boolean;
+                optionalPatternParameter?: boolean;
+                dataSourceVariant?: "unpublished";
                 variables?: {
                     [key: string]: string;
-                } | undefined;
+                };
             };
-        } | undefined;
-        _patternError?: "NOTFOUND" | "CYCLIC" | undefined;
+        };
+        _patternError?: "NOTFOUND" | "CYCLIC";
         _overrides?: {
             [key: string]: {
                 parameters?: {
@@ -262,29 +350,57 @@ declare const useUniformContextualEditing: ({ initialCompositionValue, enhance,
                         connectedData?: {
                             pointer: string;
                             syntax: "jptr";
-                            failureAction?: "a" | "p" | "t" | "c" | undefined;
-                            failureLogLevel?: "i" | "e" | "w" | undefined;
-                            failureDefault?: string | undefined;
-                        } | undefined;
+                            failureAction?: "t" | "p" | "c" | "a";
+                            failureLogLevel?: "e" | "w" | "i";
+                            failureDefault?: string;
+                        };
                         locales?: {
                             [key: string]: unknown;
-                        } | undefined;
+                        };
+                        conditions?: {
+                            when: {
+                                op?: "&" | "|";
+                                clauses: ({
+                                    rule: string;
+                                    source?: string;
+                                    op: string;
+                                    value: string | string[];
+                                } | any)[];
+                            };
+                            value: unknown;
+                            id: number;
+                        }[];
+                        localesConditions?: {
+                            [key: string]: {
+                                when: {
+                                    op?: "&" | "|";
+                                    clauses: ({
+                                        rule: string;
+                                        source?: string;
+                                        op: string;
+                                        value: string | string[];
+                                    } | any)[];
+                                };
+                                value: unknown;
+                                id: number;
+                            }[];
+                        };
                     };
-                } | undefined;
+                };
                 slots?: {
                     [key: string]: any[];
-                } | undefined;
-                variant?: string | undefined;
+                };
+                variant?: string;
             };
-        } | undefined;
+        };
         _overridability?: {
             parameters?: {
                 [key: string]: "yes" | "no";
-            } | undefined;
-            variants?: boolean | undefined;
-            hideLockedParameters?: boolean | undefined;
-        } | undefined;
-        _locales?: string[] | undefined;
+            };
+            variants?: boolean;
+            hideLockedParameters?: boolean;
+        };
+        _locales?: string[];
     } | undefined;
     isContextualEditing: boolean;
 };
@@ -357,6 +473,14 @@ type UniformRichTextProps = {
      * for rendering a rich text node
      */
     resolveRichTextRenderer?: RenderRichTextComponentResolver;
+    /**
+     * Sets the value to show in Canvas editor when the parameter value is empty.
+     * Can be a static string, or a function to generate the placeholder out of parameter info.
+     * @default undefined
+     */
+    placeholder?: string | ((parameter: {
+        id: string;
+    }) => string | undefined);
 } & Omit<React$1.HTMLAttributes<HTMLDivElement>, 'children'>;
 /**
  * Adds rendering support for Uniform Rich Text parameters
@@ -366,14 +490,22 @@ declare const UniformRichText: React$1.ForwardRefExoticComponent<{
      * The name of the  HTML tag to render.
      * @default "div"
      */
-    as?: React$1.ElementType<any> | undefined;
+    as?: React$1.ElementType;
     /** The ID of the parameter. */
     parameterId: string;
     /**
      * A function which can provide a custom react component
      * for rendering a rich text node
      */
-    resolveRichTextRenderer?: RenderRichTextComponentResolver | undefined;
+    resolveRichTextRenderer?: RenderRichTextComponentResolver;
+    /**
+     * Sets the value to show in Canvas editor when the parameter value is empty.
+     * Can be a static string, or a function to generate the placeholder out of parameter info.
+     * @default undefined
+     */
+    placeholder?: string | ((parameter: {
+        id: string;
+    }) => string | undefined);
 } & Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> & React$1.RefAttributes<unknown>>;
 
 type UniformRichTextNodeProps = {
@@ -481,7 +613,7 @@ declare const useUniformContextualEditingState: ({ global, }?: UseUniformContext
 declare const componentStore: ComponentStore;
 declare const registerUniformComponent: ({ type, variantId, component, }: {
     type: string;
-    variantId?: string | undefined;
+    variantId?: string;
     component: React.ComponentType<ComponentProps<any>>;
 }) => void;
 declare const componentStoreResolver: RenderComponentResolver;

package/dist/index.esm.js

@@ -234,7 +234,11 @@ var PureContextualEditingComponentWrapper = ({
 import React4, { createContext, useContext } from "react";
 
 // src/hooks/useClientConditionsComposition.ts
-import { evaluateWalkTreeVisibility, walkNodeTree } from "@uniformdev/canvas";
+import {
+  evaluateWalkTreeNodeVisibility,
+  evaluateWalkTreePropertyCriteria,
+  walkNodeTree
+} from "@uniformdev/canvas";
 import { produce } from "immer";
 import { useMemo as useMemo2 } from "react";
 
@@ -261,7 +265,8 @@ function useClientConditionsComposition(data) {
     try {
       return produce(data, (draft) => {
         walkNodeTree(draft, (context) => {
-          evaluateWalkTreeVisibility({ context, rules, showIndeterminate: false });
+          evaluateWalkTreeNodeVisibility({ context, rules, showIndeterminate: false });
+          evaluateWalkTreePropertyCriteria({ node: context.node, rules, keepIndeterminate: false });
         });
       });
     } catch (e) {
@@ -690,15 +695,12 @@ import {
   ATTRIBUTE_PARAMETER_ID,
   ATTRIBUTE_PARAMETER_TYPE
 } from "@uniformdev/canvas";
-import {
-  isRichTextValue,
-  isRichTextValueConsideredEmpty
-} from "@uniformdev/richtext";
-import React18, { useMemo as useMemo5 } from "react";
+import { isRichTextValue, isRichTextValueConsideredEmpty } from "@uniformdev/richtext";
+import React19 from "react";
 
 // src/components/UniformRichText/UniformRichTextNode.tsx
 import { isRichTextNode } from "@uniformdev/richtext";
-import React17 from "react";
+import React18 from "react";
 
 // src/components/UniformRichText/nodes/HeadingRichTextNode.tsx
 import React9 from "react";
@@ -752,19 +754,28 @@ var ParagraphRichTextNode = ({ children, node }) => {
   );
 };
 
-// src/components/UniformRichText/nodes/TabRichTextNode.tsx
+// src/components/UniformRichText/nodes/TableCellRichTextNode.tsx
+import { getRichTextTagFromTableCellHeaderState } from "@uniformdev/richtext";
 import React15 from "react";
+var TableCellRichTextNode = ({ children, node }) => {
+  const { headerState } = node;
+  const TableCellTag = getRichTextTagFromTableCellHeaderState(headerState);
+  return /* @__PURE__ */ React15.createElement(TableCellTag, null, children);
+};
+
+// src/components/UniformRichText/nodes/TabRichTextNode.tsx
+import React16 from "react";
 var TabRichTextNode = () => {
-  return /* @__PURE__ */ React15.createElement(React15.Fragment, null, "	");
+  return /* @__PURE__ */ React16.createElement(React16.Fragment, null, "	");
 };
 
 // src/components/UniformRichText/nodes/TextRichTextNode.tsx
 import { getRichTextTagsFromTextFormat } from "@uniformdev/richtext";
-import React16 from "react";
+import React17 from "react";
 var TextRichTextNode = ({ node }) => {
   const { text, format } = node;
   const tags = getRichTextTagsFromTextFormat(format);
-  return /* @__PURE__ */ React16.createElement(React16.Fragment, null, tags.length > 0 ? tags.reduceRight((children, Tag) => /* @__PURE__ */ React16.createElement(Tag, null, children), text) : text);
+  return /* @__PURE__ */ React17.createElement(React17.Fragment, null, tags.length > 0 ? tags.reduceRight((children, Tag) => /* @__PURE__ */ React17.createElement(Tag, null, children), text) : text);
 };
 
 // src/components/UniformRichText/UniformRichTextNode.tsx
@@ -778,8 +789,8 @@ function UniformRichTextNode({ node, ...props }) {
   if (!NodeRenderer) {
     return null;
   }
-  const children = node.children ? node.children.map((childNode, i) => /* @__PURE__ */ React17.createElement(UniformRichTextNode, { ...props, key: i, node: childNode })) : null;
-  return /* @__PURE__ */ React17.createElement(NodeRenderer, { node }, children);
+  const children = node.children ? node.children.map((childNode, i) => /* @__PURE__ */ React18.createElement(UniformRichTextNode, { ...props, key: i, node: childNode })) : null;
+  return /* @__PURE__ */ React18.createElement(NodeRenderer, { node }, children);
 }
 var rendererMap = /* @__PURE__ */ new Map([
   ["heading", HeadingRichTextNode],
@@ -788,48 +799,59 @@ var rendererMap = /* @__PURE__ */ new Map([
   ["list", ListRichTextNode],
   ["listitem", ListItemRichTextNode],
   ["paragraph", ParagraphRichTextNode],
-  ["quote", ({ children }) => /* @__PURE__ */ React17.createElement("blockquote", null, children)],
+  ["quote", ({ children }) => /* @__PURE__ */ React18.createElement("blockquote", null, children)],
   [
     "code",
-    ({ children }) => /* @__PURE__ */ React17.createElement("pre", null, /* @__PURE__ */ React17.createElement("code", null, children))
+    ({ children }) => /* @__PURE__ */ React18.createElement("pre", null, /* @__PURE__ */ React18.createElement("code", null, children))
   ],
-  ["root", ({ children }) => /* @__PURE__ */ React17.createElement(React17.Fragment, null, children)],
+  ["root", ({ children }) => /* @__PURE__ */ React18.createElement(React18.Fragment, null, children)],
   ["text", TextRichTextNode],
-  ["tab", TabRichTextNode]
+  ["tab", TabRichTextNode],
+  [
+    "table",
+    ({ children }) => /* @__PURE__ */ React18.createElement("table", null, /* @__PURE__ */ React18.createElement("tbody", null, children))
+  ],
+  ["tablerow", ({ children }) => /* @__PURE__ */ React18.createElement("tr", null, children)],
+  ["tablecell", TableCellRichTextNode]
 ]);
 var resolveRichTextDefaultRenderer = (node) => {
   return rendererMap.get(node.type);
 };
 
 // src/components/UniformRichText/UniformRichText.tsx
-var UniformRichText = React18.forwardRef(function UniformRichText2({ parameterId, resolveRichTextRenderer, as: Tag = "div", ...props }, ref) {
-  const { data: componentData } = useUniformCurrentComponent();
-  const parameter = useMemo5(() => {
-    var _a;
-    return (_a = componentData == null ? void 0 : componentData.parameters) == null ? void 0 : _a[parameterId];
-  }, [componentData, parameterId]);
-  const value = useMemo5(() => parameter == null ? void 0 : parameter.value, [parameter]);
-  if (!value || !isRichTextValue(value) || isRichTextValueConsideredEmpty(value)) return null;
-  return Tag === null ? /* @__PURE__ */ React18.createElement(UniformRichTextNode, { node: value.root, resolveRichTextRenderer }) : /* @__PURE__ */ React18.createElement(
+var UniformRichText = React19.forwardRef(function UniformRichText2({ parameterId, resolveRichTextRenderer, as: Tag = "div", placeholder, ...props }, ref) {
+  var _a;
+  const { data: componentData, contextualEditingDefaultPlaceholder } = useUniformCurrentComponent();
+  const { isContextualEditing } = useUniformCurrentComposition();
+  const parameter = (_a = componentData == null ? void 0 : componentData.parameters) == null ? void 0 : _a[parameterId];
+  if (!parameter) {
+    return null;
+  }
+  const placeholderProp = placeholder != null ? placeholder : contextualEditingDefaultPlaceholder;
+  const computedPlaceholder = typeof placeholderProp === "function" ? placeholderProp({ id: parameterId }) : placeholderProp;
+  const value = parameter.value;
+  if (!value || !isRichTextValue(value)) return null;
+  if (!isContextualEditing && isRichTextValueConsideredEmpty(value)) return null;
+  return Tag === null ? /* @__PURE__ */ React19.createElement(UniformRichTextNode, { node: value.root, resolveRichTextRenderer }) : /* @__PURE__ */ React19.createElement(
     Tag,
     {
       ref,
       ...props,
-      ...{
+      ...isContextualEditing ? {
         [ATTRIBUTE_COMPONENT_ID]: componentData == null ? void 0 : componentData._id,
         [ATTRIBUTE_PARAMETER_ID]: parameterId,
         [ATTRIBUTE_PARAMETER_TYPE]: "richText"
-      }
+      } : {}
     },
-    /* @__PURE__ */ React18.createElement(UniformRichTextNode, { node: value.root, resolveRichTextRenderer })
+    isRichTextValueConsideredEmpty(value) ? /* @__PURE__ */ React19.createElement("p", null, /* @__PURE__ */ React19.createElement("i", null, computedPlaceholder)) : /* @__PURE__ */ React19.createElement(UniformRichTextNode, { node: value.root, resolveRichTextRenderer })
   );
 });
 
 // src/components/UniformText.tsx
-import React20, { useState as useState2 } from "react";
+import React21, { useState as useState2 } from "react";
 
 // src/components/PureUniformText.tsx
-import React19 from "react";
+import React20 from "react";
 var PureUniformText = ({
   as: Tag = "span",
   parameterId,
@@ -848,10 +870,10 @@ var PureUniformText = ({
     return null;
   }
   if (!isContextualEditing) {
-    return /* @__PURE__ */ React19.createElement(Tag, { style: isMultiline ? { whiteSpace: "pre-wrap" } : {}, ...props }, render(value));
+    return /* @__PURE__ */ React20.createElement(Tag, { style: isMultiline ? { whiteSpace: "pre-wrap" } : {}, ...props }, render(value));
   }
   const computedPlaceholder = typeof placeholder === "function" ? placeholder({ id: parameterId }) : placeholder;
-  return /* @__PURE__ */ React19.createElement(
+  return /* @__PURE__ */ React20.createElement(
     Tag,
     {
       ...props,
@@ -889,7 +911,7 @@ var UniformText = ({
   }
   const placeholderProp = placeholder != null ? placeholder : contextualEditingDefaultPlaceholder;
   const computedPlaceholder = typeof placeholderProp === "function" ? placeholderProp({ id: parameterId }) : placeholderProp;
-  return /* @__PURE__ */ React20.createElement(
+  return /* @__PURE__ */ React21.createElement(
     PureUniformText,
     {
       ...props,
@@ -967,7 +989,7 @@ import {
   createCanvasChannel as createCanvasChannel2,
   isUpdateContextualEditingStateInternalMessage
 } from "@uniformdev/canvas";
-import { useEffect as useEffect3, useMemo as useMemo6, useState as useState3 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo5, useState as useState3 } from "react";
 var useUniformContextualEditingState = ({
   global = false
 } = {}) => {
@@ -977,7 +999,7 @@ var useUniformContextualEditingState = ({
   const [previewMode, setPreviewMode] = useState3(
     isContextualEditing ? "editor" : void 0
   );
-  const channel = useMemo6(() => {
+  const channel = useMemo5(() => {
     if (!isContextualEditing) {
       return;
     }
@@ -1011,7 +1033,7 @@ var useUniformContextualEditingState = ({
       unsubscribe();
     };
   }, [global, channel, componentData == null ? void 0 : componentData._id, setSelectedComponentReference, setPreviewMode]);
-  return useMemo6(
+  return useMemo5(
     () => ({
       isContextualEditing,
       selectedComponentReference,