afformative 0.6.3 → 0.7.0-beta.1

package/README.md

@@ -11,11 +11,11 @@ A standardized way to format values in your React components.
 </h3>
 
 <p align="center">
-Afformative helps UI component libraries visualise arbitrary data in a reusable, plug-and-play fashion. Formatting dates and enumeration translations in your select fields and data grids has never been easier.
+Afformative helps UI component libraries display arbitrary data in a reusable, plug-and-play fashion. Formatting dates and enum translations in your select fields and data grids has never been easier.
 </p>
 
 <p align="center">
-  <a href="https://github.com/wafflepie/affomative/blob/master/LICENSE">
+  <a href="https://github.com/wafflepie/afformative/blob/master/LICENSE">
     <img src="https://flat.badgen.net/badge/license/MIT/blue" alt="MIT License" />
   </a>
 
@@ -26,94 +26,113 @@ Afformative helps UI component libraries visualise arbitrary data in a reusable,
 
 ## Installation
 
-Use either of these commands, depending on the package manager you prefer:
+Use one of these commands, depending on your preferred package manager:
 
 ```sh
 yarn add afformative
 
+pnpm add afformative
+
 npm i afformative
 ```
 
 ## Quick Start
 
-I'll try not to bore you too much, I promise.
-
-### The Holy Standard
+A formatter is an object with `format`, `stringify`, and `compare` methods. Formatters must be created using the `createFormatter` function.
 
-> Thou shalt not format thy values without afformative.
+`createFormatter` accepts a single object parameter. `format` is the only required property, but specifying `stringify` is recommended in most cases.
 
-A formatter is an object with a `format` method. Formatters should be created solely using the `makeFormatter` factory.
+```tsx
+import { createFormatter } from "afformative"
+import { ReactNode } from "react"
 
-```js
-import { makeFormatter } from "afformative"
-
-const upperCaseFormatter = makeFormatter(value => value.toUpperCase())
+const dateFormatter = createFormatter<Date, ReactNode>({
+  format: value => <time dateTime={value.toISOString()}>{value.toLocaleDateString()}</time>,
+  stringify: value => value.toLocaleDateString(),
+})
 
-upperCaseFormatter.format("foo") // "FOO"
+dateFormatter.format(new Date()) // <time dateTime="2026-05-30T09:17:26.263Z">30/05/2026</time>
+dateFormatter.formatAsString(new Date()) // "30/05/2026"
 ```
 
-Consume formatters in your UI component library using a conventional `formatter` prop.
+Consume formatters in your UI component library via a conventional `formatter` prop.
 
-```js
-import { makeFormatter } from "afformative"
+```tsx
+import { Formatter } from "afformative"
+import { ReactNode } from "react"
 
-// This is usually the best default formatter.
-const identityFormatter = makeFormatter(value => value)
-
-const Select = ({ formatter = identityFormatter, items, ...otherProps }) => (
-  <select {...otherProps}>
-    {items.map(item => {
-      const text = formatter.format(item)
+interface ListProps<TItem> {
+  formatter: Formatter<TItem, ReactNode>
+  items: TItem[]
+}
 
-      return (
-        <option key={item} value={item}>
-          {text}
-        </option>
-      )
-    })}
-  </select>
+const List = <TItem extends unknown>({ formatter, items }: ListProps<TItem>) => (
+  <ul>
+    {items.map(item => (
+      <li key={formatter.stringify(item)}>{formatter.format(item)}</li>
+    ))}
+  </ul>
 )
 ```
 
-### Usage Context
-
-Although formatters can render icons or custom translation components, we often need to access primitive data instead of React elements.
+The `stringify` method is useful when you need a plain string representation of a value. For example, a combobox component can use it to match items against the user's typed input.
 
-> Lexicographic sorting of items based on translations is a typical real world example, especially when you are using a custom React component for visualising the translation keys alongside the actual translations.
+## Compare
 
-This is where usage suggestions come into play. Suggestions can be used to tell formatters that a value needs to be rendered with some special care. For example, pass `"primitive"` to tell a formatter that it should return a primitive value, such as a string.
+Every formatter exposes a `compare` method, which can be used to sort values. The default implementation compares the return values of `stringify` via `localeCompare`. In the following example, `Amount` objects are sorted first by currency, then by value.
 
-```js
-import { makeFormatter } from "afformative"
+```tsx
+import { createFormatter } from "afformative"
+import { ReactNode } from "react"
 
-const booleanFormatter = makeFormatter((value, suggestions) => {
-  if (suggestions.includes("primitive")) {
-    return value ? "True" : "False"
-  }
+interface Amount {
+  currency: string
+  value: number
+}
 
-  return <Icon type={value ? "success" : "failure"} />
+const amountFormatter = createFormatter<Amount, ReactNode>({
+  format: ({ currency, value }) => (
+    <span className="currency">{`${currency} ${value.toFixed(2)}`}</span>
+  ),
+  stringify: ({ currency, value }) => `${currency} ${value.toFixed(2)}`,
+  compare: (a, b) => a.currency.localeCompare(b.currency) || a.value - b.value,
 })
 
-booleanFormatter.format(true) // <Icon type="success" />
-booleanFormatter.format(true, ["primitive"]) // "True"
+const amounts: Amount[] = [
+  { currency: "USD", value: 3 },
+  { currency: "EUR", value: 1 },
+  { currency: "EUR", value: 5 },
+  { currency: "USD", value: 2 },
+]
+
+amounts.sort(amountFormatter.compare)
+// [{ EUR, 1 }, { EUR, 5 }, { USD, 2 }, { USD, 3 }]
 ```
 
-All formatters also have the `formatAsPrimitive` method, which automatically passes the `"primitive"` suggestion in addition to all other suggestions.
+## Usage Context
 
-```js
-booleanFormatter.formatAsPrimitive(true) // "True"
-booleanFormatter.formatAsPrimitive(true, ["abbreviated"]) // "True"
-```
+You can pass an optional usage context object to all formatter methods. Let's use a dummy table component as an example.
+
+```tsx
+import { Formatter } from "afformative"
+import { ReactNode } from "react"
 
-You can also pass arbitrary data to formatters as the third argument: data context. Let's use a dummy table component as an example.
+interface TableFormatterUsageContext {
+  row: number[]
+  cellIndex: number
+}
+
+interface TableProps {
+  rows: number[][]
+  formatter: Formatter<number, ReactNode, TableFormatterUsageContext>
+}
 
-```js
-const Table = ({ rows, formatter = identityFormatter }) => (
+const Table = ({ rows, formatter }: TableProps) => (
   <table>
     {rows.map(row => (
       <tr>
         {row.map((cell, cellIndex) => (
-          <td>{formatter.format(cell, [], { row, cellIndex })}</td>
+          <td>{formatter.format(cell, { row, cellIndex })}</td>
         ))}
       </tr>
     ))}
@@ -121,72 +140,49 @@ const Table = ({ rows, formatter = identityFormatter }) => (
 )
 ```
 
-Data context allows the users of this table component to write purpose-built formatters, making it possible to take other values in the same row into account. For example, the following formatter would change the color of the cell value based on the previous value in the same row.
+Usage context allows the users of this table component to write purpose-built formatters, making it possible to take other values in the same row into account. For example, the following formatter would change the color of the cell value based on the previous value in the same row.
 
-```js
-const rowTrendFormatter = makeFormatter((value, suggestions, { row, cellIndex }) => {
-  if (cellIndex === 0) {
-    return <span>{value}</span>
-  }
+```tsx
+import { createFormatter } from "afformative"
+import { ReactNode } from "react"
 
-  const previousValue = row[cellIndex - 1]
+import { TableFormatterUsageContext } from "./Table"
 
-  return <span style={{ color: value >= previousValue ? "green" : "red" }}>{value}</span>
+const rowTrendFormatter = createFormatter<number, ReactNode, TableFormatterUsageContext>({
+  format: (value, { row, cellIndex }) => {
+    if (cellIndex === 0) {
+      return <span>{value}</span>
+    }
+
+    const previousValue = row[cellIndex - 1]
+
+    return <span style={{ color: value >= previousValue ? "green" : "red" }}>{value}</span>
+  },
 })
 ```
 
-Of course, this formatter only makes sense for our table component, nowhere else.
+This formatter only makes sense in the context of our table component.
 
-Because `row` and `cellIndex` are passed as the data context, the formatter still receives just the cell value as its first parameter! This allows us to pass other generic formatters (e.g. a currency formatter) to the table component without having to worry about the value structure.
+Because `row` and `cellIndex` are passed as the usage context, the formatter still receives only the cell value as its first parameter. This means generic formatters (e.g. a currency formatter) can be passed to the table component without any changes.
 
-### Accessing React Context Reliably
+## Accessing React Context
 
-Use hooks.
+Create formatters inside custom hooks to access React context values such as translations or application state.
 
-```js
-const useEnumFormatter = enumType => {
-  // `useSelector` is from `react-redux`, `useIntl` from `react-intl`.
-  // `makeSelectEnumTranslationKeys` is a made-up Redux selector factory.
-  const enumTranslationKeys = useSelector(makeSelectEnumTranslationKeys(enumType))
+```tsx
+const useEnumFormatter = (enumType: string): Formatter<string, ReactNode> => {
+  const enumTranslationKeys = useSelector(selectEnumTranslationKeys(enumType))
   const intl = useIntl()
 
   return useMemo(
     () =>
-      makeFormatter(value =>
-        intl.formatMessage({
-          defaultMessage: value,
-          id: enumTranslationKeys[value],
-        }),
+      createFormatter<string, ReactNode>(
+        value => <FormattedMessage defaultMessage={value} id={enumTranslationKeys[value]} />,
+        value => intl.formatMessage({ defaultMessage: value, id: enumTranslationKeys[value] }),
       ),
     [intl, enumTranslationKeys],
   )
 }
-
-const someEnumFormatter = useEnumFormatter("someEnum")
-```
-
-### Consuming Formatters
-
-As mentioned earlier, formatters should be passed to components using the conventional `formatter` prop. Alternatively, if you need to pass multiple formatters (e.g. in case of column definitions), pass an array of objects where each object has a `formatter` property.
-
-All formatters also expose the `wrap` method. You can use this method to alter the behaviour of the formatter for some specific values.
-
-```js
-const useSnowflakeAwareFormatter = formatter => {
-  const intl = useIntl()
-
-  return useMemo(
-    () =>
-      formatter.wrap((delegate, value) => {
-        if (isSnowflake(value)) {
-          return intl.formatMessage(messages.snowflake)
-        }
-
-        return delegate(value)
-      }),
-    [formatter, intl],
-  )
-}
 ```
 
 ## Changelog

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+//#region src/createFormatter.d.ts
+interface FormatterFormatDefinition<TInput, TOutput, TUsageContext extends object = object> {
+  (value: TInput, usageContext: Partial<TUsageContext>): TOutput;
+}
+interface FormatterFormat<TInput, TOutput, TUsageContext extends object = object> {
+  (value: TInput, usageContext?: Partial<TUsageContext>): TOutput;
+}
+interface FormatterStringifyDefinition<TInput, TUsageContext extends object = object> {
+  (value: TInput, usageContext: Partial<TUsageContext>): string;
+}
+interface FormatterStringify<TInput, TUsageContext extends object = object> {
+  (value: TInput, usageContext?: Partial<TUsageContext>): string;
+}
+interface FormatterCompareDefinition<TInput, TUsageContext extends object = object> {
+  (a: TInput, b: TInput, usageContext: Partial<TUsageContext>): number;
+}
+interface FormatterCompare<TInput, TUsageContext extends object = object> {
+  (a: TInput, b: TInput, usageContext?: Partial<TUsageContext>): number;
+}
+interface Formatter<TInput, TOutput, TUsageContext extends object = object> {
+  compare: FormatterCompare<TInput, TUsageContext>;
+  format: FormatterFormat<TInput, TOutput, TUsageContext>;
+  stringify: FormatterStringify<TInput, TUsageContext>;
+  name?: string;
+}
+interface CreateFormatterParam<TInput, TOutput, TUsageContext extends object = object> {
+  compare?: FormatterCompareDefinition<TInput, TUsageContext>;
+  format: FormatterFormatDefinition<TInput, TOutput, TUsageContext>;
+  stringify?: FormatterStringifyDefinition<TInput, TUsageContext>;
+}
+declare const createFormatter: <TInput, TOutput, TUsageContext extends object = object>(param: CreateFormatterParam<TInput, TOutput, TUsageContext>) => Formatter<TInput, TOutput, TUsageContext>;
+//#endregion
+export { CreateFormatterParam, Formatter, FormatterCompare, FormatterCompareDefinition, FormatterFormat, FormatterFormatDefinition, FormatterStringify, FormatterStringifyDefinition, createFormatter };

package/dist/index.mjs

@@ -0,0 +1,14 @@
+//#region src/createFormatter.ts
+const createFormatter = (param) => {
+	const { format: formatParam, stringify: stringifyParam, compare: compareParam, ...rest } = param;
+	const format = (value, usageContext) => formatParam(value, usageContext ?? {});
+	const stringify = stringifyParam ? (value, usageContext) => stringifyParam(value, usageContext ?? {}) : (value, usageContext) => String(format(value, usageContext ?? {}));
+	return {
+		compare: compareParam ? (a, b, usageContext) => compareParam(a, b, usageContext ?? {}) : (a, b, usageContext) => stringify(a, usageContext ?? {}).localeCompare(stringify(b, usageContext ?? {})),
+		format,
+		stringify,
+		...rest
+	};
+};
+//#endregion
+export { createFormatter };

package/package.json

@@ -1,11 +1,6 @@
 {
   "name": "afformative",
-  "version": "0.6.3",
-  "license": "MIT",
-  "main": "dist/afformative.cjs.js",
-  "module": "dist/afformative.esm.js",
-  "unpkg": "dist/afformative.umd.js",
-  "types": "dist/types/index.d.ts",
+  "version": "0.7.0-beta.1",
   "description": "A standardized way to format values in your React components.",
   "keywords": [
     "react",
@@ -24,15 +19,43 @@
     "values"
   ],
   "repository": "https://github.com/wafflepie/afformative",
+  "license": "MIT",
   "contributors": [
-    "Vaclav Jancarik <vaclav.janc@gmail.com>"
+    "Vaclav Jancarik <hi@wafflepie.dev>"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
   ],
-  "dependencies": {
-    "@babel/runtime": "^7.12.1"
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "pnpm run build",
+    "release": "bumpp",
+    "test": "pnpm test:prettier && pnpm run test:typescript && pnpm run test:eslint && pnpm run test:vitest",
+    "test:eslint": "eslint src",
+    "test:prettier": "prettier --check src",
+    "test:typescript": "tsc --noEmit",
+    "test:vitest": "vitest run"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260527.2",
+    "bumpp": "^11.1.0",
+    "eslint": "^10.4.1",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.22.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0",
+    "vitest": "^4.1.7"
   },
+  "packageManager": "pnpm@11.5.0+sha512.dbfcc4f81cf48597afd4bc391ffdf12c11f1a9fb83a395bfa6b0a2d9cc2fd8ffebafdb1ccbd529632153f793904c2615b7f09fe1a345473fd1c35845172a8eb1",
   "publishConfig": {
     "access": "public"
-  },
-  "sideEffects": false,
-  "gitHead": "ddc8c8682e2777c730108466792b7670d8a43f06"
+  }
 }

package/dist/afformative.cjs.js

@@ -1,61 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
-
-var ensureFormatSuggestionIntegrity = function ensureFormatSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") || !suggestions.includes("comparable") ? suggestions : ["primitive"].concat(_toConsumableArray__default["default"](suggestions));
-};
-
-var ensureFormatAsPrimitiveSuggestionIntegrity = function ensureFormatAsPrimitiveSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") ? suggestions : ["primitive"].concat(_toConsumableArray__default["default"](suggestions));
-};
-
-/**
- * Creates a new formatter.
- *
- * @param format Function used to format the value.
- * @param formatterOptions Additional options for the formatter.
- */
-var makeFormatter = function makeFormatter(format, formatterOptions) {
-  var formatter = function formatter(props) {
-    var _format, _props$suggestions;
-
-    return (_format = format(props.children, (_props$suggestions = props.suggestions) !== null && _props$suggestions !== void 0 ? _props$suggestions : [], props)) !== null && _format !== void 0 ? _format : null;
-  };
-
-  formatter.displayName = formatterOptions === null || formatterOptions === void 0 ? void 0 : formatterOptions.displayName;
-
-  formatter.format = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.formatAsPrimitive = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatAsPrimitiveSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.wrap = function (nextFormat, nextFormatterOptions) {
-    var nextFormatter = makeFormatter(function (value, suggestions, dataContext) {
-      var delegate = function delegate(delegatedValue, delegatedSuggestions, delegatedDataContext) {
-        return formatter.format(delegatedValue, delegatedSuggestions !== null && delegatedSuggestions !== void 0 ? delegatedSuggestions : suggestions, delegatedDataContext !== null && delegatedDataContext !== void 0 ? delegatedDataContext : dataContext);
-      };
-
-      return nextFormat(delegate, value, suggestions, dataContext);
-    }, nextFormatterOptions !== null && nextFormatterOptions !== void 0 ? nextFormatterOptions : formatterOptions);
-    nextFormatter.innerFormatter = formatter;
-    return nextFormatter;
-  };
-
-  return formatter;
-};
-
-exports.makeFormatter = makeFormatter;

package/dist/afformative.esm.js

@@ -1,53 +0,0 @@
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
-
-var ensureFormatSuggestionIntegrity = function ensureFormatSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") || !suggestions.includes("comparable") ? suggestions : ["primitive"].concat(_toConsumableArray(suggestions));
-};
-
-var ensureFormatAsPrimitiveSuggestionIntegrity = function ensureFormatAsPrimitiveSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") ? suggestions : ["primitive"].concat(_toConsumableArray(suggestions));
-};
-
-/**
- * Creates a new formatter.
- *
- * @param format Function used to format the value.
- * @param formatterOptions Additional options for the formatter.
- */
-var makeFormatter = function makeFormatter(format, formatterOptions) {
-  var formatter = function formatter(props) {
-    var _format, _props$suggestions;
-
-    return (_format = format(props.children, (_props$suggestions = props.suggestions) !== null && _props$suggestions !== void 0 ? _props$suggestions : [], props)) !== null && _format !== void 0 ? _format : null;
-  };
-
-  formatter.displayName = formatterOptions === null || formatterOptions === void 0 ? void 0 : formatterOptions.displayName;
-
-  formatter.format = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.formatAsPrimitive = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatAsPrimitiveSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.wrap = function (nextFormat, nextFormatterOptions) {
-    var nextFormatter = makeFormatter(function (value, suggestions, dataContext) {
-      var delegate = function delegate(delegatedValue, delegatedSuggestions, delegatedDataContext) {
-        return formatter.format(delegatedValue, delegatedSuggestions !== null && delegatedSuggestions !== void 0 ? delegatedSuggestions : suggestions, delegatedDataContext !== null && delegatedDataContext !== void 0 ? delegatedDataContext : dataContext);
-      };
-
-      return nextFormat(delegate, value, suggestions, dataContext);
-    }, nextFormatterOptions !== null && nextFormatterOptions !== void 0 ? nextFormatterOptions : formatterOptions);
-    nextFormatter.innerFormatter = formatter;
-    return nextFormatter;
-  };
-
-  return formatter;
-};
-
-export { makeFormatter };

package/dist/afformative.umd.js

@@ -1,96 +0,0 @@
-(function (global, factory) {
-typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-typeof define === 'function' && define.amd ? define(['exports'], factory) :
-(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Afformative = {}));
-})(this, (function (exports) { 'use strict';
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
-
-  return arr2;
-}
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-
-var ensureFormatSuggestionIntegrity = function ensureFormatSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") || !suggestions.includes("comparable") ? suggestions : ["primitive"].concat(_toConsumableArray(suggestions));
-};
-
-var ensureFormatAsPrimitiveSuggestionIntegrity = function ensureFormatAsPrimitiveSuggestionIntegrity(suggestions) {
-  return suggestions.includes("primitive") ? suggestions : ["primitive"].concat(_toConsumableArray(suggestions));
-};
-
-/**
- * Creates a new formatter.
- *
- * @param format Function used to format the value.
- * @param formatterOptions Additional options for the formatter.
- */
-var makeFormatter = function makeFormatter(format, formatterOptions) {
-  var formatter = function formatter(props) {
-    var _format, _props$suggestions;
-
-    return (_format = format(props.children, (_props$suggestions = props.suggestions) !== null && _props$suggestions !== void 0 ? _props$suggestions : [], props)) !== null && _format !== void 0 ? _format : null;
-  };
-
-  formatter.displayName = formatterOptions === null || formatterOptions === void 0 ? void 0 : formatterOptions.displayName;
-
-  formatter.format = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.formatAsPrimitive = function (value) {
-    var suggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    var dataContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return format(value, ensureFormatAsPrimitiveSuggestionIntegrity(suggestions), dataContext);
-  };
-
-  formatter.wrap = function (nextFormat, nextFormatterOptions) {
-    var nextFormatter = makeFormatter(function (value, suggestions, dataContext) {
-      var delegate = function delegate(delegatedValue, delegatedSuggestions, delegatedDataContext) {
-        return formatter.format(delegatedValue, delegatedSuggestions !== null && delegatedSuggestions !== void 0 ? delegatedSuggestions : suggestions, delegatedDataContext !== null && delegatedDataContext !== void 0 ? delegatedDataContext : dataContext);
-      };
-
-      return nextFormat(delegate, value, suggestions, dataContext);
-    }, nextFormatterOptions !== null && nextFormatterOptions !== void 0 ? nextFormatterOptions : formatterOptions);
-    nextFormatter.innerFormatter = formatter;
-    return nextFormatter;
-  };
-
-  return formatter;
-};
-
-exports.makeFormatter = makeFormatter;
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-}));

package/dist/afformative.umd.min.js

@@ -1 +0,0 @@
-!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).Afformative={})}(this,(function(t){"use strict";function n(t,n){(null==n||n>t.length)&&(n=t.length);for(var r=0,e=Array(n);n>r;r++)e[r]=t[r];return e}function r(t){return function(t){if(Array.isArray(t))return n(t)}(t)||function(t){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)}(t)||function(t,r){if(t){if("string"==typeof t)return n(t,r);var e=Object.prototype.toString.call(t).slice(8,-1);return"Object"===e&&t.constructor&&(e=t.constructor.name),"Map"===e||"Set"===e?Array.from(t):"Arguments"===e||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)?n(t,r):void 0}}(t)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}var e=function(t){return t.includes("primitive")||!t.includes("comparable")?t:["primitive"].concat(r(t))},i=function(t){return t.includes("primitive")?t:["primitive"].concat(r(t))};t.makeFormatter=function t(n,r){var o=function(t){var r,e;return null!==(r=n(t.children,null!==(e=t.suggestions)&&void 0!==e?e:[],t))&&void 0!==r?r:null};return o.displayName=null==r?void 0:r.displayName,o.format=function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[],i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return n(t,e(r),i)},o.formatAsPrimitive=function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[],e=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return n(t,i(r),e)},o.wrap=function(n,e){var i=t((function(t,r,e){return n((function(t,n,i){return o.format(t,null!=n?n:r,null!=i?i:e)}),t,r,e)}),null!=e?e:r);return i.innerFormatter=o,i},o},Object.defineProperty(t,"__esModule",{value:!0})}));

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./makeFormatter";
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/types/makeFormatter.d.ts

@@ -1,97 +0,0 @@
-declare type PrimitiveSuggestion = "primitive" | "comparable";
-declare type Suggestion = PrimitiveSuggestion | "abbreviated" | "as-icon"
-/**
- * @deprecated Since v0.6.3. Use `"as-icon"` or `"with-icon"` instead.
- */
- | "icon" | "verbose" | "with-icon";
-declare type DataContext = Record<string, any>;
-interface FormatterOptions {
-    /** Formatter name, useful for debugging or advanced pattern matching. */
-    displayName?: string;
-}
-interface FormatDefinition<TInput, TOutput, TPrimitiveOutput, TDataContext extends DataContext> {
-    (
-    /** Value to format. */
-    value: TInput, 
-    /** Suggestions passed by the consumer of a formatter. */
-    suggestions: Suggestion[], 
-    /** Additional data context to be used by the formatter. */
-    dataContext: Partial<TDataContext>): TOutput | TPrimitiveOutput;
-}
-interface FormatMethod<TInput, TOutput, TPrimitiveOutput, TDataContext extends DataContext> {
-    (
-    /** Value to format. */
-    value: TInput, 
-    /** Suggestions the formatter should take note of. */
-    suggestions?: Suggestion[], 
-    /** Additional data context the formatter might find useful. */
-    dataContext?: Partial<TDataContext>): TOutput | TPrimitiveOutput;
-}
-interface FormatAsPrimitiveMethod<TInput, TPrimitiveOutput, TDataContext extends DataContext> {
-    (
-    /** Value to format. */
-    value: TInput, 
-    /** Suggestions the formatter should take note of in addition to `primitive`. */
-    suggestions?: Suggestion[], 
-    /** Additional data context the formatter might find useful. */
-    dataContext?: Partial<TDataContext>): TPrimitiveOutput;
-}
-interface FormatChainDefinition<TInnerInput, TInnerOutput, TInnerPrimitiveInput, TInnerDataContext extends DataContext, TOuterInput, TOuterOutput, TOuterPrimitiveOutput, TOuterDataContext extends DataContext> {
-    (
-    /**
-     * The `formatter.format` method which can be used to delegate the formatting
-     * to the wrapped formatter. Delegation is simplified so if no suggestions or contextual
-     * props are passed, the original ones are used instead.
-     */
-    delegate: FormatMethod<TInnerInput, TInnerOutput, TInnerPrimitiveInput, TInnerDataContext>, 
-    /** Value to format. */
-    value: TOuterInput, 
-    /** Suggestions the formatter should take note of. */
-    suggestions: Suggestion[], 
-    /** Additional data context the formatter might find useful. */
-    dataContext: Partial<TOuterDataContext>): TOuterOutput | TOuterPrimitiveOutput;
-}
-declare type FormatterProps<TInput, TDataContext extends DataContext> = {
-    /** Value to format. */
-    children: TInput;
-    /** Suggestions the formatter should take note of. */
-    suggestions?: Suggestion[];
-} & Partial<TDataContext>;
-export interface Formatter<TInput, TOutput, TPrimitiveOutput = TOutput, TDataContext extends DataContext = DataContext> {
-    /** Formatter name, useful for debugging or advanced pattern matching. */
-    displayName?: string;
-    /** Formats a value. */
-    format: FormatMethod<TInput, TOutput, TPrimitiveOutput, TDataContext>;
-    /** Formats a value with the `primitive` suggestion. */
-    formatAsPrimitive: FormatAsPrimitiveMethod<TInput, TPrimitiveOutput, TDataContext>;
-    /** The callee of the `wrap` method used to produce this formatter. */
-    innerFormatter?: Formatter<any, any, any, any>;
-    /**
-     * Creates a new formatter from an existing one. Allows overriding of formatter behaviour
-     * for certain values.
-     */
-    wrap: <TNextInput = TInput, TNextOutput = TOutput, TNextPrimitiveOutput = TPrimitiveOutput, TNextDataContext extends TDataContext = TDataContext>(
-    /**
-     * Function used to format the value. Has the same signature as the one passed
-     * to `makeFormatter`, except a `delegate` function is passed in the first position.
-     * This function can be used to delegate formatting to the original (inner) formatter.
-     */
-    nextFormat: FormatChainDefinition<TInput, TOutput, TPrimitiveOutput, TDataContext, TNextInput, TNextOutput, TNextPrimitiveOutput, TNextDataContext>, 
-    /** New formatter options, replacing the original ones. */
-    nextFormatterOptions?: FormatterOptions) => Formatter<TNextInput, TNextOutput, TNextPrimitiveOutput, TNextDataContext>;
-    /**
-     * Backwards-compatible way to use the formatter as a React component.
-     *
-     * @deprecated Since v0.6.0. Prefer using the `format` method instead.
-     */
-    (props: FormatterProps<TInput, TDataContext>): TOutput | TPrimitiveOutput | null;
-}
-/**
- * Creates a new formatter.
- *
- * @param format Function used to format the value.
- * @param formatterOptions Additional options for the formatter.
- */
-export declare const makeFormatter: <TInput, TOutput, TPrimitiveOutput = TOutput, TDataContext extends DataContext = DataContext>(format: FormatDefinition<TInput, TOutput, TPrimitiveOutput, TDataContext>, formatterOptions?: FormatterOptions | undefined) => Formatter<TInput, TOutput, TPrimitiveOutput, TDataContext>;
-export {};
-//# sourceMappingURL=makeFormatter.d.ts.map

package/dist/types/makeFormatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"makeFormatter.d.ts","sourceRoot":"","sources":["../../src/makeFormatter.ts"],"names":[],"mappings":"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"}

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./makeFormatter"

package/src/makeFormatter.test.ts

@@ -1,218 +0,0 @@
-import { makeFormatter } from "./makeFormatter"
-
-const toUpperCase = (string: string) => string.toUpperCase()
-
-const upperCaseFormatter = makeFormatter<string, string>(toUpperCase)
-
-interface ValueRecord {
-  value: string
-}
-
-const valueRecordUpperCaseFormatter = makeFormatter<ValueRecord, ValueRecord, string>(
-  ({ value }, suggestions) => {
-    if (suggestions.includes("primitive")) {
-      return toUpperCase(value)
-    }
-
-    return { value: toUpperCase(value) }
-  },
-)
-
-describe("makeFormatter", () => {
-  const format = jest.fn()
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe("displayName", () => {
-    it("accepts a `displayName` option", () => {
-      const displayName = "upperCaseFormatter"
-      const formatter = makeFormatter<string, string>(toUpperCase, { displayName })
-      expect(formatter.displayName).toBe(displayName)
-    })
-  })
-
-  describe("format", () => {
-    it("handles trivial formatting", () => {
-      expect(upperCaseFormatter.format("foo")).toBe("FOO")
-    })
-
-    it("passes through non-empty suggestions", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", ["abbreviated"])
-      expect(format.mock.calls[0][1]).toEqual(["abbreviated"])
-    })
-
-    it("passes through empty suggestions", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", [])
-      expect(format.mock.calls[0][1]).toEqual([])
-    })
-
-    it("defaults suggestions to an empty array", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo")
-      expect(format.mock.calls[0][1]).toEqual([])
-    })
-
-    it("passes through the `primitive` suggestion", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", ["primitive"])
-      expect(format.mock.calls[0][1]).toEqual(["primitive"])
-    })
-
-    it("passes the `primitive` suggestion alongside `comparable` when missing", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", ["comparable"])
-      expect(format.mock.calls[0][1]).toEqual(["primitive", "comparable"])
-    })
-
-    it("does not pass the `primitive` suggestion alongside other suggestions when missing", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", ["abbreviated", "verbose"])
-      expect(format.mock.calls[0][1]).toEqual(["abbreviated", "verbose"])
-    })
-
-    it("supports data context", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo", [], { foo: "bar" })
-      expect(format.mock.calls[0][2]).toEqual({ foo: "bar" })
-    })
-
-    it("defaults data context to an empty object", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.format("foo")
-      expect(format.mock.calls[0][2]).toEqual({})
-    })
-  })
-
-  describe("formatAsPrimitive", () => {
-    it("handles trivial formatting", () => {
-      expect(upperCaseFormatter.formatAsPrimitive("foo")).toBe("FOO")
-    })
-
-    it("passes the `primitive` suggestion when no suggestions are passed", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo")
-      expect(format.mock.calls[0][1]).toEqual(["primitive"])
-    })
-
-    it("passes the `primitive` suggestion when empty suggestions are passed", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo", [])
-      expect(format.mock.calls[0][1]).toEqual(["primitive"])
-    })
-
-    it("passes the `primitive` suggestion when a different suggestion is passed", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo", ["abbreviated"])
-      expect(format.mock.calls[0][1]).toEqual(["primitive", "abbreviated"])
-    })
-
-    it("passes through the `primitive` suggestion", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo", ["primitive"])
-      expect(format.mock.calls[0][1]).toEqual(["primitive"])
-    })
-
-    it("passes the `primitive` suggestion alongside `comparable`", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo", ["comparable"])
-      expect(format.mock.calls[0][1]).toEqual(["primitive", "comparable"])
-    })
-
-    it("supports data context", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo", [], { foo: "bar" })
-      expect(format.mock.calls[0][2]).toEqual({ foo: "bar" })
-    })
-
-    it("defaults data context to an empty object", () => {
-      const formatter = makeFormatter<string, string>(format)
-      formatter.formatAsPrimitive("foo")
-      expect(format.mock.calls[0][2]).toEqual({})
-    })
-  })
-
-  describe("wrap", () => {
-    it("handles trivial wrapping", () => {
-      const formatter = makeFormatter<string, string>(format).wrap(() => "bar")
-      expect(formatter.format("foo")).toBe("bar")
-    })
-
-    it("handles single-value mapping", () => {
-      const formatter = makeFormatter<string, string>(format).wrap((delegate, value) =>
-        value === "ping" ? "pong" : delegate(value),
-      )
-
-      expect(formatter.format("ping")).toBe("pong")
-    })
-
-    it("handles delegation to the original formatter", () => {
-      const formatter = upperCaseFormatter.wrap((delegate, value) =>
-        value === "ping" ? "pong" : delegate(value),
-      )
-
-      expect(formatter.format("foo")).toBe("FOO")
-    })
-
-    it("sets the `innerFormatter` property", () => {
-      const wrappedFormatter = upperCaseFormatter.wrap((delegate, value) => delegate(value))
-      expect(wrappedFormatter.innerFormatter).toBe(upperCaseFormatter)
-    })
-
-    it("passes the `primitive` suggestion to `delegate` when using `formatAsPrimitive`", () => {
-      const formatter = valueRecordUpperCaseFormatter.wrap((delegate, value) => delegate(value))
-      expect(formatter.formatAsPrimitive({ value: "foo" })).toBe("FOO")
-    })
-
-    it("passes suggestions through to `delegate` when not overriden", () => {
-      const formatter = valueRecordUpperCaseFormatter.wrap((delegate, value) => delegate(value))
-      expect(formatter.format({ value: "foo" }, ["primitive"])).toBe("FOO")
-    })
-
-    it("supports overriding of suggestions for `delegate`", () => {
-      const formatter = valueRecordUpperCaseFormatter.wrap((delegate, value) => delegate(value, []))
-      expect(formatter.format({ value: "foo" }, ["primitive"])).toEqual({ value: "FOO" })
-    })
-
-    it("supports modifying the input structure", () => {
-      const formatter = upperCaseFormatter.wrap<ValueRecord>((delegate, { value }) =>
-        delegate(value),
-      )
-
-      expect(formatter.format({ value: "foo" })).toBe("FOO")
-    })
-
-    it("supports modifying the output structure", () => {
-      const formatter = upperCaseFormatter.wrap<ValueRecord, ValueRecord>(
-        (delegate, { value }) => ({ value: delegate(value) }),
-      )
-
-      expect(formatter.format({ value: "foo" })).toEqual({ value: "FOO" })
-    })
-
-    it("supports modifying the data context structure", () => {
-      interface ListContext {
-        row: string
-      }
-
-      const listFormatter = upperCaseFormatter.wrap<string, string, string, ListContext>(
-        (delegate, value, suggestions, { row }) => `${row}: ${delegate(value)}`,
-      )
-
-      interface GridContext extends ListContext {
-        column: string
-      }
-
-      expect(listFormatter.format("foo", [], { row: "A" })).toBe("A: FOO")
-
-      const gridFormatter = listFormatter.wrap<string, string, string, GridContext>(
-        (delegate, value, suggestions, { column }) => delegate(value).replace(":", `${column}:`),
-      )
-
-      expect(gridFormatter.format("foo", [], { row: "B", column: "1" })).toBe("B1: FOO")
-    })
-  })
-})

package/src/makeFormatter.ts

@@ -1,219 +0,0 @@
-type PrimitiveSuggestion = "primitive" | "comparable"
-
-type Suggestion =
-  | PrimitiveSuggestion
-  | "abbreviated"
-  | "as-icon"
-  /**
-   * @deprecated Since v0.6.3. Use `"as-icon"` or `"with-icon"` instead.
-   */
-  | "icon"
-  | "verbose"
-  | "with-icon"
-
-const ensureFormatSuggestionIntegrity = (suggestions: Suggestion[]): Suggestion[] =>
-  suggestions.includes("primitive") || !suggestions.includes("comparable")
-    ? suggestions
-    : ["primitive", ...suggestions]
-
-const ensureFormatAsPrimitiveSuggestionIntegrity = (suggestions: Suggestion[]): Suggestion[] =>
-  suggestions.includes("primitive") ? suggestions : ["primitive", ...suggestions]
-
-type DataContext = Record<string, any>
-
-interface FormatterOptions {
-  /** Formatter name, useful for debugging or advanced pattern matching. */
-  displayName?: string
-}
-
-interface FormatDefinition<TInput, TOutput, TPrimitiveOutput, TDataContext extends DataContext> {
-  (
-    /** Value to format. */
-    value: TInput,
-    /** Suggestions passed by the consumer of a formatter. */
-    suggestions: Suggestion[],
-    /** Additional data context to be used by the formatter. */
-    dataContext: Partial<TDataContext>,
-  ): TOutput | TPrimitiveOutput
-}
-
-interface FormatMethod<TInput, TOutput, TPrimitiveOutput, TDataContext extends DataContext> {
-  (
-    /** Value to format. */
-    value: TInput,
-    /** Suggestions the formatter should take note of. */
-    suggestions?: Suggestion[],
-    /** Additional data context the formatter might find useful. */
-    dataContext?: Partial<TDataContext>,
-  ): TOutput | TPrimitiveOutput
-}
-
-interface FormatAsPrimitiveMethod<TInput, TPrimitiveOutput, TDataContext extends DataContext> {
-  (
-    /** Value to format. */
-    value: TInput,
-    /** Suggestions the formatter should take note of in addition to `primitive`. */
-    suggestions?: Suggestion[],
-    /** Additional data context the formatter might find useful. */
-    dataContext?: Partial<TDataContext>,
-  ): TPrimitiveOutput
-}
-
-interface FormatChainDefinition<
-  TInnerInput,
-  TInnerOutput,
-  TInnerPrimitiveInput,
-  TInnerDataContext extends DataContext,
-  TOuterInput,
-  TOuterOutput,
-  TOuterPrimitiveOutput,
-  TOuterDataContext extends DataContext
-> {
-  (
-    /**
-     * The `formatter.format` method which can be used to delegate the formatting
-     * to the wrapped formatter. Delegation is simplified so if no suggestions or contextual
-     * props are passed, the original ones are used instead.
-     */
-    delegate: FormatMethod<TInnerInput, TInnerOutput, TInnerPrimitiveInput, TInnerDataContext>,
-    /** Value to format. */
-    value: TOuterInput,
-    /** Suggestions the formatter should take note of. */
-    suggestions: Suggestion[],
-    /** Additional data context the formatter might find useful. */
-    dataContext: Partial<TOuterDataContext>,
-  ): TOuterOutput | TOuterPrimitiveOutput
-}
-
-type FormatterProps<TInput, TDataContext extends DataContext> = {
-  /** Value to format. */
-  children: TInput
-  /** Suggestions the formatter should take note of. */
-  suggestions?: Suggestion[]
-} & Partial<TDataContext>
-
-export interface Formatter<
-  TInput,
-  TOutput,
-  TPrimitiveOutput = TOutput,
-  TDataContext extends DataContext = DataContext
-> {
-  /** Formatter name, useful for debugging or advanced pattern matching. */
-  displayName?: string
-  /** Formats a value. */
-  format: FormatMethod<TInput, TOutput, TPrimitiveOutput, TDataContext>
-  /** Formats a value with the `primitive` suggestion. */
-  formatAsPrimitive: FormatAsPrimitiveMethod<TInput, TPrimitiveOutput, TDataContext>
-  /** The callee of the `wrap` method used to produce this formatter. */
-  innerFormatter?: Formatter<any, any, any, any>
-  /**
-   * Creates a new formatter from an existing one. Allows overriding of formatter behaviour
-   * for certain values.
-   */
-  wrap: <
-    TNextInput = TInput,
-    TNextOutput = TOutput,
-    TNextPrimitiveOutput = TPrimitiveOutput,
-    TNextDataContext extends TDataContext = TDataContext
-  >(
-    /**
-     * Function used to format the value. Has the same signature as the one passed
-     * to `makeFormatter`, except a `delegate` function is passed in the first position.
-     * This function can be used to delegate formatting to the original (inner) formatter.
-     */
-    nextFormat: FormatChainDefinition<
-      TInput,
-      TOutput,
-      TPrimitiveOutput,
-      TDataContext,
-      TNextInput,
-      TNextOutput,
-      TNextPrimitiveOutput,
-      TNextDataContext
-    >,
-    /** New formatter options, replacing the original ones. */
-    nextFormatterOptions?: FormatterOptions,
-  ) => Formatter<TNextInput, TNextOutput, TNextPrimitiveOutput, TNextDataContext>
-  /**
-   * Backwards-compatible way to use the formatter as a React component.
-   *
-   * @deprecated Since v0.6.0. Prefer using the `format` method instead.
-   */
-  (props: FormatterProps<TInput, TDataContext>): TOutput | TPrimitiveOutput | null
-}
-
-/**
- * Creates a new formatter.
- *
- * @param format Function used to format the value.
- * @param formatterOptions Additional options for the formatter.
- */
-export const makeFormatter = <
-  TInput,
-  TOutput,
-  TPrimitiveOutput = TOutput,
-  TDataContext extends DataContext = DataContext
->(
-  format: FormatDefinition<TInput, TOutput, TPrimitiveOutput, TDataContext>,
-  formatterOptions?: FormatterOptions,
-): Formatter<TInput, TOutput, TPrimitiveOutput, TDataContext> => {
-  const formatter: Formatter<TInput, TOutput, TPrimitiveOutput, TDataContext> = props =>
-    format(props.children, props.suggestions ?? [], props) ?? null
-
-  formatter.displayName = formatterOptions?.displayName
-
-  formatter.format = (value, suggestions = [], dataContext = {}) =>
-    format(value, ensureFormatSuggestionIntegrity(suggestions), dataContext)
-
-  formatter.formatAsPrimitive = (value, suggestions = [], dataContext = {}) =>
-    format(
-      value,
-      ensureFormatAsPrimitiveSuggestionIntegrity(suggestions),
-      dataContext,
-    ) as TPrimitiveOutput
-
-  formatter.wrap = <
-    TNextInput,
-    TNextOutput,
-    TNextPrimitiveOutput,
-    TNextDataContext extends TDataContext
-  >(
-    nextFormat: FormatChainDefinition<
-      TInput,
-      TOutput,
-      TPrimitiveOutput,
-      TDataContext,
-      TNextInput,
-      TNextOutput,
-      TNextPrimitiveOutput,
-      TNextDataContext
-    >,
-    nextFormatterOptions?: FormatterOptions,
-  ) => {
-    const nextFormatter = makeFormatter<
-      TNextInput,
-      TNextOutput,
-      TNextPrimitiveOutput,
-      TNextDataContext
-    >((value, suggestions, dataContext) => {
-      const delegate: FormatMethod<TInput, TOutput, TPrimitiveOutput, TDataContext> = (
-        delegatedValue,
-        delegatedSuggestions,
-        delegatedDataContext,
-      ) =>
-        formatter.format(
-          delegatedValue,
-          delegatedSuggestions ?? suggestions,
-          delegatedDataContext ?? dataContext,
-        )
-
-      return nextFormat(delegate, value, suggestions, dataContext)
-    }, nextFormatterOptions ?? formatterOptions)
-
-    nextFormatter.innerFormatter = formatter
-
-    return nextFormatter
-  }
-
-  return formatter
-}

package/tsconfig.build.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../tsconfig.build.json",
-  "compilerOptions": {
-    "declarationDir": "./dist/types"
-  }
-}