@nixxie-cms/core 1.0.0

package/fields/types/bytes/dist/nixxie-cms-core-fields-types-bytes.cjs.js

@@ -0,0 +1,221 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('pluralize');
+var nextFields = require('../../../../dist/next-fields-49c025ef.cjs.js');
+require('../../../../dist/resolve-hooks-66fe8a8e.cjs.js');
+var nonNullGraphql = require('../../../../dist/non-null-graphql-17b83ddc.cjs.js');
+require('node:path');
+require('@graphql-ts/schema');
+require('@graphql-ts/extend');
+var utils = require('../../../../dist/utils-b031e11c.cjs.js');
+var graphql = require('graphql');
+require('decimal.js');
+require('graphql-upload/GraphQLUpload.js');
+
+function bytes(config = {}) {
+  var _config$graphql$scala, _config$graphql, _config$db, _validation$isRequire, _validation$length$mi, _validation$length, _validation$length2, _validation$length3;
+  const {
+    defaultValue = null,
+    isIndexed,
+    validation = {}
+  } = config;
+  const scalar = (_config$graphql$scala = (_config$graphql = config.graphql) === null || _config$graphql === void 0 ? void 0 : _config$graphql.scalar) !== null && _config$graphql$scala !== void 0 ? _config$graphql$scala : nextFields.g.Hex;
+  (_config$db = config.db) !== null && _config$db !== void 0 ? _config$db : config.db = {};
+  const isRequired = (_validation$isRequire = validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false;
+  const min = validation.isRequired ? (_validation$length$mi = (_validation$length = validation.length) === null || _validation$length === void 0 ? void 0 : _validation$length.min) !== null && _validation$length$mi !== void 0 ? _validation$length$mi : 1 : (_validation$length2 = validation.length) === null || _validation$length2 === void 0 ? void 0 : _validation$length2.min;
+  const max = (_validation$length3 = validation.length) === null || _validation$length3 === void 0 ? void 0 : _validation$length3.max;
+  return meta => {
+    var _config$db2, _config$db3, _config$db4;
+    {
+      const serializedExample = scalar.serialize(new Uint8Array([0]));
+      if (typeof serializedExample !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    }
+    if (min !== undefined && (!Number.isInteger(min) || min < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.min: ${min} but it must be a positive integer`);
+    }
+    if (max !== undefined && (!Number.isInteger(max) || max < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.max: ${max} but it must be a positive integer`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.length.max that is less than the validation.length.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = nonNullGraphql.makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (value != null) {
+        if (min !== undefined && value.length < min) {
+          if (min === 1) {
+            addValidationError(`value must not be empty`);
+          } else {
+            addValidationError(`value must be at least ${min} bytes long`);
+          }
+        }
+        if (max !== undefined && value.length > max) {
+          addValidationError(`value must be no longer than ${max} bytes`);
+        }
+      }
+    } : undefined);
+    let clientSideDefaultValue = null;
+    if (defaultValue !== null) {
+      clientSideDefaultValue = scalar.serialize(defaultValue);
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    } else if (mode === 'required') {
+      clientSideDefaultValue = scalar.serialize(new Uint8Array(0));
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    }
+    return nextFields.fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Bytes',
+      default: defaultValue === null ? undefined : {
+        kind: 'literal',
+        value: defaultValue
+      },
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      map: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.map,
+      nativeType: (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.nativeType,
+      extendPrismaSchema: (_config$db4 = config.db) === null || _config$db4 === void 0 ? void 0 : _config$db4.extendPrismaSchema
+    })({
+      ...config,
+      ...nonNullGraphql.defaultIsRequired(config, isRequired),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: nextFields.g.arg({
+            type: scalar
+          })
+        } : undefined,
+        where: {
+          arg: nextFields.g.arg({
+            type: mode === 'optional' ? getNullableFilterType(scalar) : getFilterType(scalar)
+          })
+        },
+        create: {
+          arg: nextFields.g.arg({
+            type: scalar
+          }),
+          resolve(val) {
+            if (val !== undefined) return val;
+            return defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+          }
+        },
+        update: {
+          arg: nextFields.g.arg({
+            type: scalar
+          })
+        },
+        orderBy: {
+          arg: nextFields.g.arg({
+            type: nextFields.orderDirectionEnum
+          })
+        }
+      },
+      output: nextFields.g.field({
+        type: scalar
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/bytes',
+      views: '@nixxie-cms/core/fields/types/bytes/views',
+      getAdminMeta() {
+        return {
+          defaultValue: clientSideDefaultValue,
+          isNullable: mode === 'optional'
+        };
+      }
+    });
+  };
+}
+// the weakMemoizes are important so reusing the same scalar type for multiple `bytes` fields uses the same (===) filter type
+// rather than a duplicate one which would cause an error about two types with the same name
+const getFilterType = utils.weakMemoize(scalar => {
+  const filter = nextFields.g.inputObject({
+    name: `${scalar.name}Filter`,
+    fields: () => ({
+      equals: nextFields.g.arg({
+        type: scalar
+      }),
+      in: nextFields.g.arg({
+        type: nextFields.g.list(nextFields.g.nonNull(scalar))
+      }),
+      notIn: nextFields.g.arg({
+        type: nextFields.g.list(nextFields.g.nonNull(scalar))
+      }),
+      not: nextFields.g.arg({
+        type: filter
+      })
+    })
+  });
+  return filter;
+});
+const getNullableFilterType = utils.weakMemoize(scalar => {
+  const filter = nextFields.g.inputObject({
+    name: `${scalar.name}NullableFilter`,
+    fields: () => ({
+      equals: nextFields.g.arg({
+        type: scalar
+      }),
+      in: nextFields.g.arg({
+        type: nextFields.g.list(nextFields.g.nonNull(scalar))
+      }),
+      notIn: nextFields.g.arg({
+        type: nextFields.g.list(nextFields.g.nonNull(scalar))
+      }),
+      not: nextFields.g.arg({
+        type: filter
+      })
+    })
+  });
+  return filter;
+});
+function bytesScalar(opts) {
+  return nextFields.g.scalar({
+    name: opts.name,
+    description: opts.description,
+    specifiedByURL: opts.specifiedByURL,
+    parseLiteral(value) {
+      if (value.kind !== 'StringValue') {
+        throw new graphql.GraphQLError(`${opts.name} only accepts values as strings`);
+      }
+      return opts.parse(value.value);
+    },
+    parseValue(value) {
+      // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+      if (value instanceof Uint8Array) {
+        // duplicate it though to avoid any weirdness with the array being mutated
+        // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+        return Uint8Array.from(value);
+      }
+      if (typeof value !== 'string') {
+        throw new graphql.GraphQLError(`${opts.name} only accepts values as strings`);
+      }
+      return opts.parse(value);
+    },
+    serialize(value) {
+      if (!(value instanceof Uint8Array)) {
+        throw new graphql.GraphQLError(`unexpected value provided to ${opts.name} scalar: ${value}`);
+      }
+      return opts.serialize(value);
+    }
+  });
+}
+
+exports.bytes = bytes;
+exports.bytesScalar = bytesScalar;

package/fields/types/bytes/dist/nixxie-cms-core-fields-types-bytes.esm.js

@@ -0,0 +1,216 @@
+import 'pluralize';
+import { g, f as fieldType, o as orderDirectionEnum } from '../../../../dist/next-fields-9bf04ed8.esm.js';
+import '../../../../dist/resolve-hooks-17aafd37.esm.js';
+import { m as makeValidateHook, d as defaultIsRequired } from '../../../../dist/non-null-graphql-5315718c.esm.js';
+import 'node:path';
+import '@graphql-ts/schema';
+import '@graphql-ts/extend';
+import { w as weakMemoize } from '../../../../dist/utils-f9556354.esm.js';
+import { GraphQLError } from 'graphql';
+import 'decimal.js';
+import 'graphql-upload/GraphQLUpload.js';
+
+function bytes(config = {}) {
+  var _config$graphql$scala, _config$graphql, _config$db, _validation$isRequire, _validation$length$mi, _validation$length, _validation$length2, _validation$length3;
+  const {
+    defaultValue = null,
+    isIndexed,
+    validation = {}
+  } = config;
+  const scalar = (_config$graphql$scala = (_config$graphql = config.graphql) === null || _config$graphql === void 0 ? void 0 : _config$graphql.scalar) !== null && _config$graphql$scala !== void 0 ? _config$graphql$scala : g.Hex;
+  (_config$db = config.db) !== null && _config$db !== void 0 ? _config$db : config.db = {};
+  const isRequired = (_validation$isRequire = validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false;
+  const min = validation.isRequired ? (_validation$length$mi = (_validation$length = validation.length) === null || _validation$length === void 0 ? void 0 : _validation$length.min) !== null && _validation$length$mi !== void 0 ? _validation$length$mi : 1 : (_validation$length2 = validation.length) === null || _validation$length2 === void 0 ? void 0 : _validation$length2.min;
+  const max = (_validation$length3 = validation.length) === null || _validation$length3 === void 0 ? void 0 : _validation$length3.max;
+  return meta => {
+    var _config$db2, _config$db3, _config$db4;
+    {
+      const serializedExample = scalar.serialize(new Uint8Array([0]));
+      if (typeof serializedExample !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    }
+    if (min !== undefined && (!Number.isInteger(min) || min < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.min: ${min} but it must be a positive integer`);
+    }
+    if (max !== undefined && (!Number.isInteger(max) || max < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.max: ${max} but it must be a positive integer`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.length.max that is less than the validation.length.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (value != null) {
+        if (min !== undefined && value.length < min) {
+          if (min === 1) {
+            addValidationError(`value must not be empty`);
+          } else {
+            addValidationError(`value must be at least ${min} bytes long`);
+          }
+        }
+        if (max !== undefined && value.length > max) {
+          addValidationError(`value must be no longer than ${max} bytes`);
+        }
+      }
+    } : undefined);
+    let clientSideDefaultValue = null;
+    if (defaultValue !== null) {
+      clientSideDefaultValue = scalar.serialize(defaultValue);
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    } else if (mode === 'required') {
+      clientSideDefaultValue = scalar.serialize(new Uint8Array(0));
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(`The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`);
+      }
+    }
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Bytes',
+      default: defaultValue === null ? undefined : {
+        kind: 'literal',
+        value: defaultValue
+      },
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      map: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.map,
+      nativeType: (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.nativeType,
+      extendPrismaSchema: (_config$db4 = config.db) === null || _config$db4 === void 0 ? void 0 : _config$db4.extendPrismaSchema
+    })({
+      ...config,
+      ...defaultIsRequired(config, isRequired),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: scalar
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: mode === 'optional' ? getNullableFilterType(scalar) : getFilterType(scalar)
+          })
+        },
+        create: {
+          arg: g.arg({
+            type: scalar
+          }),
+          resolve(val) {
+            if (val !== undefined) return val;
+            return defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: scalar
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: scalar
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/bytes',
+      views: '@nixxie-cms/core/fields/types/bytes/views',
+      getAdminMeta() {
+        return {
+          defaultValue: clientSideDefaultValue,
+          isNullable: mode === 'optional'
+        };
+      }
+    });
+  };
+}
+// the weakMemoizes are important so reusing the same scalar type for multiple `bytes` fields uses the same (===) filter type
+// rather than a duplicate one which would cause an error about two types with the same name
+const getFilterType = weakMemoize(scalar => {
+  const filter = g.inputObject({
+    name: `${scalar.name}Filter`,
+    fields: () => ({
+      equals: g.arg({
+        type: scalar
+      }),
+      in: g.arg({
+        type: g.list(g.nonNull(scalar))
+      }),
+      notIn: g.arg({
+        type: g.list(g.nonNull(scalar))
+      }),
+      not: g.arg({
+        type: filter
+      })
+    })
+  });
+  return filter;
+});
+const getNullableFilterType = weakMemoize(scalar => {
+  const filter = g.inputObject({
+    name: `${scalar.name}NullableFilter`,
+    fields: () => ({
+      equals: g.arg({
+        type: scalar
+      }),
+      in: g.arg({
+        type: g.list(g.nonNull(scalar))
+      }),
+      notIn: g.arg({
+        type: g.list(g.nonNull(scalar))
+      }),
+      not: g.arg({
+        type: filter
+      })
+    })
+  });
+  return filter;
+});
+function bytesScalar(opts) {
+  return g.scalar({
+    name: opts.name,
+    description: opts.description,
+    specifiedByURL: opts.specifiedByURL,
+    parseLiteral(value) {
+      if (value.kind !== 'StringValue') {
+        throw new GraphQLError(`${opts.name} only accepts values as strings`);
+      }
+      return opts.parse(value.value);
+    },
+    parseValue(value) {
+      // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+      if (value instanceof Uint8Array) {
+        // duplicate it though to avoid any weirdness with the array being mutated
+        // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+        return Uint8Array.from(value);
+      }
+      if (typeof value !== 'string') {
+        throw new GraphQLError(`${opts.name} only accepts values as strings`);
+      }
+      return opts.parse(value);
+    },
+    serialize(value) {
+      if (!(value instanceof Uint8Array)) {
+        throw new GraphQLError(`unexpected value provided to ${opts.name} scalar: ${value}`);
+      }
+      return opts.serialize(value);
+    }
+  });
+}
+
+export { bytes, bytesScalar };

package/fields/types/bytes/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/nixxie-cms-core-fields-types-bytes.cjs.js",
+  "module": "dist/nixxie-cms-core-fields-types-bytes.esm.js"
+}

package/fields/types/bytes/views/dist/nixxie-cms-core-fields-types-bytes-views.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../../../dist/declarations/src/fields/types/bytes/views/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibml4eGllLWNtcy1jb3JlLWZpZWxkcy10eXBlcy1ieXRlcy12aWV3cy5janMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2Rpc3QvZGVjbGFyYXRpb25zL3NyYy9maWVsZHMvdHlwZXMvYnl0ZXMvdmlld3MvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/fields/types/bytes/views/dist/nixxie-cms-core-fields-types-bytes-views.cjs.js

@@ -0,0 +1,239 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var textField = require('@keystar/ui/text-field');
+var react = require('react');
+require('@keystar/ui/table');
+var jsxRuntime = require('react/jsx-runtime');
+require('@keystar/ui/style');
+var NullableFieldWrapper = require('../../../../../dist/NullableFieldWrapper-daa0a080.cjs.js');
+require('@babel/runtime/helpers/defineProperty');
+require('@keystar/ui/button');
+require('@keystar/ui/dialog');
+require('@keystar/ui/icon');
+require('@keystar/ui/icon/icons/alertTriangleIcon');
+require('@keystar/ui/layout');
+require('@keystar/ui/notice');
+require('@keystar/ui/slots');
+require('@keystar/ui/typography');
+require('next/link');
+require('apollo-upload-client/UploadHttpLink.mjs');
+require('next/head');
+require('@keystar/ui/core');
+require('@keystar/ui/toast');
+require('@nixxie-cms/core/admin-ui/router');
+require('@keystar/ui/icon/icons/chevronLeftIcon');
+require('@keystar/ui/icon/icons/chevronRightIcon');
+require('@keystar/ui/icon/icons/undo2Icon');
+require('@keystar/ui/picker');
+require('@keystar/ui/tag');
+require('@keystar/ui/tooltip');
+require('../../../../../dist/admin-meta-graphql-c8f926e9.cjs.js');
+require('@apollo/client');
+require('@apollo/client/react');
+require('next/router');
+require('@react-aria/utils');
+require('@keystar/ui/icon/icons/textCursorInputIcon');
+require('@keystar/ui/utils');
+require('fast-deep-equal');
+require('graphql');
+var utils = require('../../../../../dist/utils-b031e11c.cjs.js');
+require('@keystar/ui/checkbox');
+require('@keystar/ui/icon/icons/cornerDownRightIcon');
+
+function Field(props) {
+  const {
+    autoFocus,
+    field,
+    forceValidation,
+    onChange,
+    value,
+    isRequired
+  } = props;
+  const [shouldShowErrors, setShouldShowErrors] = react.useState(false);
+  const validationMessages = validate(value, props.isRequired, field.label);
+  const isReadOnly = onChange == null;
+  const isNull = value.inner.kind === 'null';
+  return /*#__PURE__*/jsxRuntime.jsx(NullableFieldWrapper.NullableFieldWrapper, {
+    isAllowed: field.isNullable,
+    autoFocus: isNull && autoFocus,
+    label: field.label,
+    isReadOnly: isReadOnly,
+    isNull: isNull,
+    onChange: () => {
+      if (!onChange) return;
+      const inner = value.inner.kind === 'value' ? {
+        kind: 'null',
+        prev: value.inner.value
+      } : {
+        kind: 'value',
+        value: value.inner.prev
+      };
+      onChange({
+        ...value,
+        inner
+      });
+    },
+    children: /*#__PURE__*/jsxRuntime.jsx(textField.TextField, {
+      autoFocus: autoFocus,
+      description: field.description,
+      label: field.label,
+      errorMessage: !!validationMessages.length && (shouldShowErrors || forceValidation) ? validationMessages.join('. ') : undefined,
+      isDisabled: isNull,
+      isReadOnly: isReadOnly,
+      isRequired: isRequired,
+      onBlur: () => {
+        setShouldShowErrors(true);
+      },
+      onChange: textValue => {
+        if (!onChange) return;
+        onChange({
+          ...value,
+          inner: {
+            kind: 'value',
+            value: textValue
+          }
+        });
+      }
+      // maintain the previous value when set to null in aid of continuity for
+      // the user. it will be cleared when the item is saved
+      ,
+      value: value.inner.kind === 'value' ? value.inner.value : value.inner.prev
+    })
+  });
+}
+function validate(value, isRequired, fieldLabel) {
+  // if the value is the same as the initial for an update, we don't want to block saving
+  // since we're not gonna send it anyway if it's the same
+  // and going "fix this thing that is unrelated to the thing you're doing" is bad
+  // and also bc it could be null bc of read access control
+  if (value.kind === 'update' && (value.initial.kind === 'null' && value.inner.kind === 'null' || value.initial.kind === 'value' && value.inner.kind === 'value' && value.inner.value === value.initial.value)) {
+    return [];
+  }
+  if (value.inner.kind === 'null') {
+    if (isRequired) return [`${fieldLabel} is required`];
+    return [];
+  }
+  return [];
+}
+function deserializeTextValue(value) {
+  if (value === null) return {
+    kind: 'null',
+    prev: ''
+  };
+  return {
+    kind: 'value',
+    value
+  };
+}
+function controller(config) {
+  return {
+    fieldKey: config.fieldKey,
+    label: config.label,
+    description: config.description,
+    defaultValue: {
+      kind: 'create',
+      inner: deserializeTextValue(config.fieldMeta.defaultValue)
+    },
+    isNullable: config.fieldMeta.isNullable,
+    deserialize: data => {
+      const inner = deserializeTextValue(data[config.fieldKey]);
+      return {
+        kind: 'update',
+        inner,
+        initial: inner
+      };
+    },
+    serialize: value => ({
+      [config.fieldKey]: value.inner.kind === 'null' ? null : value.inner.value
+    }),
+    validate: (val, opts) => validate(val, opts.isRequired, config.label).length === 0,
+    graphqlSelection: config.fieldKey,
+    filter: {
+      Filter(props) {
+        const {
+          autoFocus,
+          context,
+          typeLabel,
+          onChange,
+          type,
+          value,
+          ...otherProps
+        } = props;
+        const labelProps = context === 'add' ? {
+          label: config.label,
+          description: typeLabel
+        } : {
+          label: typeLabel
+        };
+
+        // NOTE: "type" is a valid attribute for an input element, however the
+        // prop represents a filter type in this context e.g. "contains_i", so
+        // we're filtering it out of the spread.
+        // TODO: more consideration is needed for the filter API, once
+        // requirements are better understood.
+        return /*#__PURE__*/jsxRuntime.jsx(textField.TextField, {
+          ...otherProps,
+          ...labelProps,
+          autoFocus: autoFocus,
+          onChange: onChange,
+          value: value
+        });
+      },
+      Label({
+        label,
+        value
+      }) {
+        const trimmedLabel = label.toLowerCase().replace(' exactly', '');
+        return `${trimmedLabel} "${value}"`;
+      },
+      graphql: ({
+        type,
+        value
+      }) => {
+        const isNot = type.startsWith('not_');
+        const filter = {
+          equals: value
+        };
+        return {
+          [config.fieldKey]: {
+            ...(isNot ? {
+              not: filter
+            } : filter)
+          }
+        };
+      },
+      parseGraphQL: value => {
+        return utils.entriesTyped(value).flatMap(([type, _value]) => {
+          if (!_value) return [];
+          if (type === 'equals') return {
+            type: 'is_i',
+            value: _value
+          };
+          if (type === 'not') {
+            const notValue = _value;
+            if (notValue !== null && notValue !== void 0 && notValue.equals) return {
+              type: 'not_i',
+              value: notValue.equals
+            };
+          }
+          return [];
+        });
+      },
+      types: {
+        is_i: {
+          label: 'Is exactly',
+          initialValue: ''
+        },
+        not_i: {
+          label: 'Is not exactly',
+          initialValue: ''
+        }
+      }
+    }
+  };
+}
+
+exports.Field = Field;
+exports.controller = controller;