lkb-fields-document 1.0.0 → 1.0.1

package/dist/utils-6409f730.cjs.js

@@ -1,747 +0,0 @@
-'use strict';
-
-var slate = require('slate');
-
-const allMarks = ['bold', 'italic', 'underline', 'strikethrough', 'code', 'superscript', 'subscript', 'keyboard'];
-typeof window != 'undefined' && /Mac|iPod|iPhone|iPad/.test(window.navigator.platform);
-function isElementActive(editor, format) {
-  const [match] = slate.Editor.nodes(editor, {
-    match: n => n.type === format
-  });
-  return !!match;
-}
-function clearFormatting(editor) {
-  slate.Transforms.unwrapNodes(editor, {
-    match: node => node.type === 'heading' || node.type === 'blockquote' || node.type === 'code'
-  });
-  slate.Transforms.unsetNodes(editor, allMarks, {
-    match: slate.Text.isText
-  });
-}
-function moveChildren(editor, parent, to, shouldMoveNode = () => true) {
-  const parentPath = slate.Path.isPath(parent) ? parent : parent[1];
-  const parentNode = slate.Path.isPath(parent) ? slate.Node.get(editor, parentPath) : parent[0];
-  if (!(slate.Element.isElement(parentNode) && slate.Editor.isBlock(editor, parentNode))) return;
-  for (let i = parentNode.children.length - 1; i >= 0; i--) {
-    if (shouldMoveNode(parentNode.children[i])) {
-      const childPath = [...parentPath, i];
-      slate.Transforms.moveNodes(editor, {
-        at: childPath,
-        to
-      });
-    }
-  }
-}
-function insertNodesButReplaceIfSelectionIsAtEmptyParagraphOrHeading(editor, nodes, slate$1) {
-  var _pathRefForEmptyNodeA;
-  let pathRefForEmptyNodeAtCursor;
-  const entry = slate.Editor.above(editor, {
-    match: node => node.type === 'heading' || node.type === 'paragraph'
-  });
-  if (entry && slate.Node.string(entry[0]) === '') {
-    pathRefForEmptyNodeAtCursor = slate.Editor.pathRef(editor, entry[1]);
-  }
-  slate.Transforms.insertNodes(editor, nodes);
-  const path = (_pathRefForEmptyNodeA = pathRefForEmptyNodeAtCursor) === null || _pathRefForEmptyNodeA === void 0 ? void 0 : _pathRefForEmptyNodeA.unref();
-  if (path) {
-    slate.Transforms.removeNodes(editor, {
-      at: path
-    });
-    // even though the selection is in the right place after the removeNodes
-    // for some reason the editor blurs so we need to focus it again
-    slate$1 === null || slate$1 === void 0 || slate$1.ReactEditor.focus(editor);
-  }
-}
-
-/**
- * This is equivalent to Editor.after except that it ignores points that have no content
- * like the point in a void text node, an empty text node and the last point in a text node
- */
-// TODO: this would probably break if you were trying to get the last point in the editor?
-function EditorAfterButIgnoringingPointsWithNoContent(editor, at, {
-  distance = 1
-} = {}) {
-  const anchor = slate.Editor.point(editor, at, {
-    edge: 'end'
-  });
-  const focus = slate.Editor.end(editor, []);
-  const range = {
-    anchor,
-    focus
-  };
-  let d = 0;
-  let target;
-  for (const p of slate.Editor.positions(editor, {
-    at: range
-  })) {
-    if (d > distance) break;
-
-    // this is the important change
-    const node = slate.Node.get(editor, p.path);
-    if (node.text.length === p.offset) continue;
-    if (d !== 0) {
-      target = p;
-    }
-    d++;
-  }
-  return target;
-}
-function nodeTypeMatcher(...args) {
-  if (args.length === 1) {
-    const type = args[0];
-    return node => node.type === type;
-  }
-  const set = new Set(args);
-  return node => typeof node.type === 'string' && set.has(node.type);
-}
-function assert(condition) {
-  if (!condition) throw new Error('failed assert');
-}
-
-function getInitialValue(type, componentBlock) {
-  const props = getInitialPropsValue({
-    kind: 'object',
-    fields: componentBlock.schema
-  });
-  return {
-    type: 'component-block',
-    component: type,
-    props,
-    children: findChildPropPaths(props, componentBlock.schema).map(x => ({
-      type: `component-${x.options.kind}-prop`,
-      propPath: x.path,
-      children: [x.options.kind === 'block' ? {
-        type: 'paragraph',
-        children: [{
-          text: ''
-        }]
-      } : {
-        text: ''
-      }]
-    }))
-  };
-}
-function getInitialPropsValue(schema) {
-  switch (schema.kind) {
-    case 'form':
-      return schema.defaultValue;
-    case 'child':
-      return null;
-    case 'relationship':
-      return schema.many ? [] : null;
-    case 'conditional':
-      {
-        const defaultValue = schema.discriminant.defaultValue;
-        return {
-          discriminant: defaultValue,
-          value: getInitialPropsValue(schema.values[defaultValue.toString()])
-        };
-      }
-    case 'object':
-      {
-        const obj = {};
-        for (const key of Object.keys(schema.fields)) {
-          obj[key] = getInitialPropsValue(schema.fields[key]);
-        }
-        return obj;
-      }
-    case 'array':
-      return [];
-  }
-  assertNever(schema);
-}
-function getInitialPropsValueFromInitializer(schema, initializer) {
-  switch (schema.kind) {
-    case 'form':
-      return initializer === undefined ? schema.defaultValue : initializer;
-    case 'child':
-      return null;
-    case 'relationship':
-      return initializer === undefined ? schema.many ? [] : null : initializer;
-    case 'conditional':
-      {
-        const defaultValue = initializer === undefined ? schema.discriminant.defaultValue : initializer.discriminant;
-        return {
-          discriminant: defaultValue,
-          value: getInitialPropsValueFromInitializer(schema.values[defaultValue.toString()], initializer === undefined ? undefined : initializer.value)
-        };
-      }
-    case 'object':
-      {
-        const obj = {};
-        for (const key of Object.keys(schema.fields)) {
-          obj[key] = getInitialPropsValueFromInitializer(schema.fields[key], initializer === undefined ? undefined : initializer[key]);
-        }
-        return obj;
-      }
-    case 'array':
-      {
-        return (initializer !== null && initializer !== void 0 ? initializer : []).map(x => getInitialPropsValueFromInitializer(schema.element, x.value));
-      }
-  }
-  assertNever(schema);
-}
-function updateValue(schema, currentValue, updater) {
-  if (updater === undefined) return currentValue;
-  switch (schema.kind) {
-    case 'relationship':
-      return updater;
-    case 'form':
-      return updater;
-    case 'child':
-      return null;
-    case 'conditional':
-      {
-        return {
-          discriminant: updater.discriminant,
-          value: updater.discriminant === currentValue.discriminant ? updateValue(schema.values[updater.discriminant.toString()], currentValue.value, updater.value) : getInitialPropsValueFromInitializer(schema.values[updater.discriminant.toString()], updater.value)
-        };
-      }
-    case 'object':
-      {
-        const obj = {};
-        for (const key of Object.keys(schema.fields)) {
-          obj[key] = updateValue(schema.fields[key], currentValue[key], updater[key]);
-        }
-        return obj;
-      }
-    case 'array':
-      {
-        const currentArrVal = currentValue;
-        const newVal = updater;
-        const uniqueKeys = new Set();
-        for (const x of newVal) {
-          if (x.key !== undefined) {
-            if (uniqueKeys.has(x.key)) {
-              throw new Error('Array elements must have unique keys');
-            }
-            uniqueKeys.add(x.key);
-          }
-        }
-        const keys = newVal.map(x => {
-          if (x.key !== undefined) return x.key;
-          let elementKey = getNewArrayElementKey();
-          // just in case someone gives a key that is above our counter
-          while (uniqueKeys.has(elementKey)) {
-            elementKey = getNewArrayElementKey();
-          }
-          uniqueKeys.add(elementKey);
-          return elementKey;
-        });
-        const prevKeys = getKeysForArrayValue(currentArrVal);
-        const prevValuesByKey = new Map(currentArrVal.map((value, i) => {
-          return [prevKeys[i], value];
-        }));
-        const val = newVal.map((x, i) => {
-          const id = keys[i];
-          if (prevValuesByKey.has(id)) {
-            return updateValue(schema.element, prevValuesByKey.get(id), x.value);
-          }
-          return getInitialPropsValueFromInitializer(schema.element, x.value);
-        });
-        setKeysForArrayValue(val, keys);
-        return val;
-      }
-  }
-  assertNever(schema);
-}
-
-const arrayValuesToElementKeys = new WeakMap();
-let counter = 0;
-function getKeysForArrayValue(value) {
-  if (!arrayValuesToElementKeys.has(value)) {
-    arrayValuesToElementKeys.set(value, Array.from({
-      length: value.length
-    }, getNewArrayElementKey));
-  }
-  return arrayValuesToElementKeys.get(value);
-}
-function setKeysForArrayValue(value, elementIds) {
-  arrayValuesToElementKeys.set(value, elementIds);
-}
-function getNewArrayElementKey() {
-  return (counter++).toString();
-}
-function castToMemoizedInfoForSchema(val) {
-  return val;
-}
-function getOrInsert(map, key, val) {
-  if (!map.has(key)) map.set(key, val(key));
-  return map.get(key);
-}
-function createGetPreviewProps(rootSchema, rootOnChange, getChildFieldElement) {
-  const memoizedInfoForSchema = castToMemoizedInfoForSchema({
-    form(schema, onChange) {
-      return newVal => onChange(() => newVal);
-    },
-    array(schema, onChange) {
-      return {
-        rawOnChange: onChange,
-        inner: new Map(),
-        onChange(updater) {
-          onChange(value => updateValue(schema, value, updater));
-        }
-      };
-    },
-    child() {},
-    conditional(schema, onChange) {
-      return {
-        onChange: (discriminant, value) => onChange(v => updateValue(schema, v, {
-          discriminant,
-          value
-        })),
-        onChangeForValue: cb => onChange(v => ({
-          discriminant: v.discriminant,
-          value: cb(v.value)
-        }))
-      };
-    },
-    object(schema, onChange) {
-      return {
-        onChange: updater => {
-          onChange(value => updateValue(schema, value, updater));
-        },
-        innerOnChanges: Object.fromEntries(Object.keys(schema.fields).map(key => {
-          return [key, newVal => {
-            onChange(v => ({
-              ...v,
-              [key]: newVal(v[key])
-            }));
-          }];
-        }))
-      };
-    },
-    relationship(schema, onChange) {
-      return newVal => onChange(() => newVal);
-    }
-  });
-  const previewPropsFactories = {
-    form(schema, value, onChange) {
-      return {
-        value: value,
-        onChange,
-        options: schema.options,
-        schema: schema
-      };
-    },
-    child(schema, value, onChange, path) {
-      return {
-        element: getChildFieldElement(path),
-        schema: schema
-      };
-    },
-    object(schema, value, memoized, path, getInnerProp) {
-      const fields = {};
-      for (const key of Object.keys(schema.fields)) {
-        fields[key] = getInnerProp(schema.fields[key], value[key], memoized.innerOnChanges[key], key);
-      }
-      const previewProps = {
-        fields,
-        onChange: memoized.onChange,
-        schema: schema
-      };
-      return previewProps;
-    },
-    array(schema, value, memoized, path, getInnerProp) {
-      if (!Array.isArray(value)) throw new TypeError('Expected array');
-      const arrayValue = value;
-      const keys = getKeysForArrayValue(arrayValue);
-      const unusedKeys = new Set([...keys]);
-      const props = {
-        elements: arrayValue.map((val, i) => {
-          const key = keys[i];
-          unusedKeys.delete(key);
-          const element = getOrInsert(memoized.inner, key, () => {
-            const onChange = val => {
-              memoized.rawOnChange(prev => {
-                const keys = getKeysForArrayValue(prev);
-                const index = keys.indexOf(key);
-                const newValue = [...prev];
-                newValue[index] = val(newValue[index]);
-                setKeysForArrayValue(newValue, keys);
-                return newValue;
-              });
-            };
-            const element = getInnerProp(schema.element, val, onChange, key);
-            return {
-              element,
-              elementWithKey: {
-                ...element,
-                key
-              },
-              onChange
-            };
-          });
-          const currentInnerProp = getInnerProp(schema.element, val, element.onChange, key);
-          if (element.element !== currentInnerProp) {
-            element.element = currentInnerProp;
-            element.elementWithKey = {
-              ...currentInnerProp,
-              key
-            };
-          }
-          return element.elementWithKey;
-        }),
-        schema: schema,
-        onChange: memoized.onChange
-      };
-      for (const key of unusedKeys) {
-        memoized.inner.delete(key);
-      }
-      return props;
-    },
-    relationship(schema, value, onChange) {
-      const props = {
-        value: value,
-        onChange,
-        schema: schema
-      };
-      return props;
-    },
-    conditional(schema, value, memoized, path, getInnerProp) {
-      const props = {
-        discriminant: value.discriminant,
-        onChange: memoized.onChange,
-        options: schema.discriminant.options,
-        value: getInnerProp(schema.values[value.discriminant.toString()], value.value, memoized.onChangeForValue, 'value'),
-        schema: schema
-      };
-      return props;
-    }
-  };
-  function getPreviewPropsForProp(schema, value, memoedThing, path, getInnerProp) {
-    return previewPropsFactories[schema.kind](schema, value, memoedThing, path, getInnerProp);
-  }
-  function getInitialMemoState(schema, value, onChange, path) {
-    const innerState = new Map();
-    const memoizedInfo = memoizedInfoForSchema[schema.kind](schema, onChange);
-    const state = {
-      value,
-      inner: innerState,
-      props: getPreviewPropsForProp(schema, value, memoizedInfo, path, (schema, value, onChange, key) => {
-        const state = getInitialMemoState(schema, value, onChange, path.concat(key));
-        innerState.set(key, state);
-        return state.props;
-      }),
-      schema: schema,
-      cached: memoizedInfo
-    };
-    return state;
-  }
-  function getUpToDateProps(schema, value, onChange, memoState, path) {
-    if (memoState.schema !== schema) {
-      Object.assign(memoState, getInitialMemoState(schema, value, onChange, path));
-      return memoState.props;
-    }
-    if (memoState.value === value) {
-      return memoState.props;
-    }
-    memoState.value = value;
-    const unusedKeys = new Set(memoState.inner.keys());
-    memoState.props = getPreviewPropsForProp(schema, value, memoState.cached, path, (schema, value, onChange, innerMemoStateKey) => {
-      unusedKeys.delete(innerMemoStateKey);
-      if (!memoState.inner.has(innerMemoStateKey)) {
-        const innerState = getInitialMemoState(schema, value, onChange, path.concat(innerMemoStateKey));
-        memoState.inner.set(innerMemoStateKey, innerState);
-        return innerState.props;
-      }
-      return getUpToDateProps(schema, value, onChange, memoState.inner.get(innerMemoStateKey), path.concat(innerMemoStateKey));
-    });
-    for (const key of unusedKeys) {
-      memoState.inner.delete(key);
-    }
-    return memoState.props;
-  }
-  let memoState;
-  return value => {
-    if (memoState === undefined) {
-      memoState = getInitialMemoState(rootSchema, value, rootOnChange, []);
-      return memoState.props;
-    }
-    return getUpToDateProps(rootSchema, value, rootOnChange, memoState, []);
-  };
-}
-
-function findChildPropPathsForProp(value, schema, path) {
-  switch (schema.kind) {
-    case 'form':
-    case 'relationship':
-      return [];
-    case 'child':
-      return [{
-        path: path,
-        options: schema.options
-      }];
-    case 'conditional':
-      return findChildPropPathsForProp(value.value, schema.values[value.discriminant], path.concat('value'));
-    case 'object':
-      {
-        const paths = [];
-        Object.keys(schema.fields).forEach(key => {
-          paths.push(...findChildPropPathsForProp(value[key], schema.fields[key], path.concat(key)));
-        });
-        return paths;
-      }
-    case 'array':
-      {
-        const paths = [];
-        value.forEach((val, i) => {
-          paths.push(...findChildPropPathsForProp(val, schema.element, path.concat(i)));
-        });
-        return paths;
-      }
-  }
-}
-function findChildPropPaths(value, props) {
-  const propPaths = findChildPropPathsForProp(value, {
-    kind: 'object',
-    fields: props
-  }, []);
-  if (propPaths.length) return propPaths;
-  return [{
-    path: undefined,
-    options: {
-      kind: 'inline',
-      placeholder: ''
-    }
-  }];
-}
-function assertNever(arg) {
-  throw new Error('expected to never be called but received: ' + JSON.stringify(arg));
-}
-function getDocumentFeaturesForChildField(editorDocumentFeatures, options) {
-  var _options$formatting, _options$formatting3, _options$formatting4, _options$formatting5, _options$formatting6, _options$formatting7, _options$formatting8;
-  // an important note for this: normalization based on document features
-  // is done based on the document features returned here
-  // and the editor document features
-  // so the result for any given child prop will be the things that are
-  // allowed by both these document features
-  // AND the editor document features
-  const inlineMarksFromOptions = (_options$formatting = options.formatting) === null || _options$formatting === void 0 ? void 0 : _options$formatting.inlineMarks;
-  const inlineMarks = inlineMarksFromOptions === 'inherit' ? 'inherit' : Object.fromEntries(Object.keys(editorDocumentFeatures.formatting.inlineMarks).map(mark => {
-    return [mark, !!(inlineMarksFromOptions || {})[mark]];
-  }));
-  if (options.kind === 'inline') {
-    var _options$formatting2;
-    return {
-      kind: 'inline',
-      inlineMarks,
-      documentFeatures: {
-        links: options.links === 'inherit',
-        relationships: options.relationships === 'inherit'
-      },
-      softBreaks: ((_options$formatting2 = options.formatting) === null || _options$formatting2 === void 0 ? void 0 : _options$formatting2.softBreaks) === 'inherit'
-    };
-  }
-  return {
-    kind: 'block',
-    inlineMarks,
-    softBreaks: ((_options$formatting3 = options.formatting) === null || _options$formatting3 === void 0 ? void 0 : _options$formatting3.softBreaks) === 'inherit',
-    documentFeatures: {
-      layouts: [],
-      dividers: options.dividers === 'inherit' ? editorDocumentFeatures.dividers : false,
-      formatting: {
-        alignment: ((_options$formatting4 = options.formatting) === null || _options$formatting4 === void 0 ? void 0 : _options$formatting4.alignment) === 'inherit' ? editorDocumentFeatures.formatting.alignment : {
-          center: false,
-          end: false
-        },
-        blockTypes: ((_options$formatting5 = options.formatting) === null || _options$formatting5 === void 0 ? void 0 : _options$formatting5.blockTypes) === 'inherit' ? editorDocumentFeatures.formatting.blockTypes : {
-          blockquote: false,
-          code: false
-        },
-        headingLevels: ((_options$formatting6 = options.formatting) === null || _options$formatting6 === void 0 ? void 0 : _options$formatting6.headingLevels) === 'inherit' ? editorDocumentFeatures.formatting.headingLevels : ((_options$formatting7 = options.formatting) === null || _options$formatting7 === void 0 ? void 0 : _options$formatting7.headingLevels) || [],
-        listTypes: ((_options$formatting8 = options.formatting) === null || _options$formatting8 === void 0 ? void 0 : _options$formatting8.listTypes) === 'inherit' ? editorDocumentFeatures.formatting.listTypes : {
-          ordered: false,
-          unordered: false
-        }
-      },
-      links: options.links === 'inherit',
-      relationships: options.relationships === 'inherit'
-    },
-    componentBlocks: options.componentBlocks === 'inherit'
-  };
-}
-function getSchemaAtPropPathInner(path, value, schema) {
-  // because we're checking the length here
-  // the non-null asserts on shift below are fine
-  if (path.length === 0) return schema;
-  if (schema.kind === 'child' || schema.kind === 'form' || schema.kind === 'relationship') return;
-  if (schema.kind === 'conditional') {
-    const key = path.shift();
-    if (key === 'discriminant') return getSchemaAtPropPathInner(path, value.discriminant, schema.discriminant);
-    if (key === 'value') {
-      const propVal = schema.values[value.discriminant];
-      return getSchemaAtPropPathInner(path, value.value, propVal);
-    }
-    return;
-  }
-  if (schema.kind === 'object') {
-    const key = path.shift();
-    return getSchemaAtPropPathInner(path, value[key], schema.fields[key]);
-  }
-  if (schema.kind === 'array') {
-    const index = path.shift();
-    return getSchemaAtPropPathInner(path, value[index], schema.element);
-  }
-  assertNever(schema);
-}
-function getSchemaAtPropPath(path, value, props) {
-  return getSchemaAtPropPathInner([...path], value, {
-    kind: 'object',
-    fields: props
-  });
-}
-function clientSideValidateProp(schema, value) {
-  if (schema.kind === 'child') return true;
-  if (schema.kind === 'relationship') return true;
-  if (schema.kind === 'form') return schema.validate(value);
-  if (typeof value !== 'object') return false;
-  if (value === null) return false;
-  switch (schema.kind) {
-    case 'conditional':
-      {
-        if (!('discriminant' in value) || !('value' in value)) return false;
-        if (!schema.discriminant.validate(value.discriminant)) return false;
-        return clientSideValidateProp(schema.values[
-        // not actually gonna always be a string but just let property access do the coercion
-        value.discriminant], value.value);
-      }
-    case 'object':
-      {
-        for (const [key, childProp] of Object.entries(schema.fields)) {
-          if (!clientSideValidateProp(childProp, value[key])) return false;
-        }
-        return true;
-      }
-    case 'array':
-      {
-        if (!Array.isArray(value)) return false;
-        for (const innerVal of value) {
-          if (!clientSideValidateProp(schema.element, innerVal)) return false;
-        }
-        return true;
-      }
-  }
-}
-function getAncestorSchemas(rootSchema, path, value) {
-  const ancestors = [];
-  const currentPath = [...path];
-  let currentProp = rootSchema;
-  let currentValue = value;
-  while (currentPath.length) {
-    ancestors.push(currentProp);
-    const key = currentPath.shift(); // this code only runs when path.length is truthy so this non-null assertion is fine
-    if (currentProp.kind === 'array') {
-      currentProp = currentProp.element;
-      currentValue = currentValue[key];
-    } else if (currentProp.kind === 'conditional') {
-      currentProp = currentProp.values[value.discriminant];
-      currentValue = currentValue.value;
-    } else if (currentProp.kind === 'object') {
-      currentValue = currentValue[key];
-      currentProp = currentProp.fields[key];
-    } else if (currentProp.kind === 'child' || currentProp.kind === 'form' || currentProp.kind === 'relationship') {
-      throw new Error(`unexpected prop "${key}"`);
-    } else {
-      assertNever(currentProp);
-    }
-  }
-  return ancestors;
-}
-function getValueAtPropPath(value, inputPath) {
-  const path = [...inputPath];
-  while (path.length) {
-    const key = path.shift();
-    value = value[key];
-  }
-  return value;
-}
-function traverseProps(schema, value, visitor, path = []) {
-  if (schema.kind === 'form' || schema.kind === 'relationship' || schema.kind === 'child') {
-    visitor(schema, value, path);
-    return;
-  }
-  if (schema.kind === 'object') {
-    for (const [key, childProp] of Object.entries(schema.fields)) {
-      traverseProps(childProp, value[key], visitor, [...path, key]);
-    }
-    visitor(schema, value, path);
-    return;
-  }
-  if (schema.kind === 'array') {
-    for (const [idx, val] of value.entries()) {
-      traverseProps(schema.element, val, visitor, path.concat(idx));
-    }
-    return visitor(schema, value, path);
-  }
-  if (schema.kind === 'conditional') {
-    const discriminant = value.discriminant;
-    visitor(schema, discriminant, path.concat('discriminant'));
-    traverseProps(schema.values[discriminant.toString()], value.value, visitor, path.concat('value'));
-    visitor(schema, value, path);
-    return;
-  }
-  assertNever(schema);
-}
-function replaceValueAtPropPath(schema, value, newValue, path) {
-  if (path.length === 0) return newValue;
-  const [key, ...newPath] = path;
-  if (schema.kind === 'object') {
-    return {
-      ...value,
-      [key]: replaceValueAtPropPath(schema.fields[key], value[key], newValue, newPath)
-    };
-  }
-  if (schema.kind === 'conditional') {
-    const conditionalValue = value;
-    // replaceValueAtPropPath should not be used to only update the discriminant of a conditional field
-    // if you want to update the discriminant of a conditional field, replace the value of the whole conditional field
-    assert(key === 'value');
-    return {
-      discriminant: conditionalValue.discriminant,
-      value: replaceValueAtPropPath(schema.values[key], conditionalValue.value, newValue, newPath)
-    };
-  }
-  if (schema.kind === 'array') {
-    const prevVal = value;
-    const newVal = [...prevVal];
-    setKeysForArrayValue(newVal, getKeysForArrayValue(prevVal));
-    newVal[key] = replaceValueAtPropPath(schema.element, newVal[key], newValue, newPath);
-    return newVal;
-  }
-
-  // we should never reach here since form, relationship or child fields don't contain other fields
-  // so the only thing that can happen to them is to be replaced which happens at the start of this function when path.length === 0
-  assert(schema.kind !== 'form' && schema.kind !== 'relationship' && schema.kind !== 'child');
-  assertNever(schema);
-}
-function getPlaceholderTextForPropPath(propPath, fields, formProps) {
-  const field = getSchemaAtPropPath(propPath, formProps, fields);
-  if ((field === null || field === void 0 ? void 0 : field.kind) === 'child') return field.options.placeholder;
-  return '';
-}
-
-exports.EditorAfterButIgnoringingPointsWithNoContent = EditorAfterButIgnoringingPointsWithNoContent;
-exports.allMarks = allMarks;
-exports.assert = assert;
-exports.assertNever = assertNever;
-exports.clearFormatting = clearFormatting;
-exports.clientSideValidateProp = clientSideValidateProp;
-exports.createGetPreviewProps = createGetPreviewProps;
-exports.findChildPropPaths = findChildPropPaths;
-exports.getAncestorSchemas = getAncestorSchemas;
-exports.getDocumentFeaturesForChildField = getDocumentFeaturesForChildField;
-exports.getInitialPropsValue = getInitialPropsValue;
-exports.getInitialValue = getInitialValue;
-exports.getKeysForArrayValue = getKeysForArrayValue;
-exports.getNewArrayElementKey = getNewArrayElementKey;
-exports.getPlaceholderTextForPropPath = getPlaceholderTextForPropPath;
-exports.getSchemaAtPropPath = getSchemaAtPropPath;
-exports.getValueAtPropPath = getValueAtPropPath;
-exports.insertNodesButReplaceIfSelectionIsAtEmptyParagraphOrHeading = insertNodesButReplaceIfSelectionIsAtEmptyParagraphOrHeading;
-exports.isElementActive = isElementActive;
-exports.moveChildren = moveChildren;
-exports.nodeTypeMatcher = nodeTypeMatcher;
-exports.replaceValueAtPropPath = replaceValueAtPropPath;
-exports.setKeysForArrayValue = setKeysForArrayValue;
-exports.traverseProps = traverseProps;