@humanforest/nuxt-layer 0.1.0

package/packages/ui/src/filter/filterClause.ts

@@ -0,0 +1,265 @@
+// A clause is one row of the filter bar. The list is flat and conjunctive: every clause narrows the
+// last, and two clauses on one field stay separate rows.
+//
+// Every function here is pure and takes the clause list in and hands a new one back, so the whole
+// model is testable in node and FFilterBar holds no logic of its own. Ids are passed IN rather than
+// generated, for the same reason — the bar supplies useId().
+import {
+  OPERATOR_LABEL,
+  defaultOperator,
+  type FilterField,
+  type FilterSchema,
+  type Operator,
+} from './filterSchema';
+
+export type RelativeUnit = 'day' | 'week' | 'month';
+
+export type ClauseValue =
+  | string[]
+  | string
+  | number
+  // A range holds a pair: two numbers on a number field, two ISO strings on a date field. A half
+  // filled range keeps a null in the empty half and stays inert until both ends are in.
+  | [number | null, number | null]
+  | [string | null, string | null]
+  | { n: number; unit: RelativeUnit }
+  | boolean
+  | null;
+
+export interface Clause {
+  /** Stable across edits — the v-for key, and where focus returns after a value picker closes. */
+  id: string;
+  /** A key into the schema. */
+  field: string;
+  operator: Operator;
+  value: ClauseValue;
+}
+
+/** What an untouched clause of each kind holds. An enum starts empty, a boolean starts true. */
+const emptyValue = (field: FilterField): ClauseValue => {
+  switch (field.kind) {
+    case 'enum':
+      return [];
+    case 'text':
+      return '';
+    case 'boolean':
+      return true;
+    default:
+      return null;
+  }
+};
+
+/** The set/singular pairs the promotion rule moves between, negation preserved. */
+const PROMOTE: Partial<Record<Operator, Operator>> = { is: 'isAnyOf', isNot: 'isNoneOf' };
+const DEMOTE: Partial<Record<Operator, Operator>> = { isAnyOf: 'is', isNoneOf: 'isNot' };
+
+export const addClause = (
+  clauses: Clause[],
+  field: string,
+  schema: FilterSchema,
+  id: string,
+): Clause[] => {
+  const declared = schema[field];
+  if (!declared) return clauses;
+  return [
+    ...clauses,
+    { id, field, operator: defaultOperator(declared.kind), value: emptyValue(declared) },
+  ];
+};
+
+const isScalar = (v: unknown): v is string | number => typeof v === 'number' || typeof v === 'string';
+
+/** An upper-bound operator inherits the top of a range; everything else inherits the bottom. */
+const prefersUpperEnd = (operator: Operator): boolean =>
+  operator === 'isBelow' || operator === 'isBefore';
+
+/**
+ * The one value a pair or a window can offer when it collapses to a single-value operator. A range
+ * hands over the end that reads the same way under the new operator — `10 – 40` narrowed to
+ * `is below` means 40, not 10 — and falls back to whichever end is filled.
+ */
+const scalarFor = (value: ClauseValue, to: Operator): ClauseValue => {
+  if (Array.isArray(value)) {
+    const ends = value as unknown[];
+    const first = prefersUpperEnd(to) ? ends[1] : ends[0];
+    const second = prefersUpperEnd(to) ? ends[0] : ends[1];
+    if (isScalar(first)) return first;
+    return isScalar(second) ? second : null;
+  }
+  if (value !== null && typeof value === 'object') return null;
+  return value;
+};
+
+/**
+ * The value SHAPE follows the operator: `is between` holds a pair, `in the last` holds a window, and
+ * every other operator holds one value. Changing the operator carries across what already fits rather
+ * than stranding a value the new operator cannot read. Operators that share a shape — the enum
+ * one/many pairs, a text `contains` becoming an `is` — are left untouched.
+ */
+const reshapeValue = (value: ClauseValue, from: Operator, to: Operator): ClauseValue => {
+  const wasRange = from === 'isBetween';
+  const wasWindow = from === 'inTheLast';
+  const isRange = to === 'isBetween';
+  const isWindow = to === 'inTheLast';
+  if (!wasRange && !wasWindow && !isRange && !isWindow) return value;
+
+  if (isRange) {
+    if (Array.isArray(value) && value.length === 2) return value;
+    const first = scalarFor(value, to);
+    // An upper-bound value becoming a range keeps its meaning as the range's top end. Both ends are
+    // the same kind by construction — a number field's scalar or a date field's ISO string.
+    if (isScalar(first)) {
+      return (prefersUpperEnd(from) ? [null, first] : [first, null]) as ClauseValue;
+    }
+    return [null, null];
+  }
+  if (isWindow) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) return value;
+    return { n: 0, unit: 'day' };
+  }
+  // Leaving a range or a window for a single-value operator: a window has no scalar to keep.
+  return wasWindow ? null : scalarFor(value, to);
+};
+
+/**
+ * Applies a patch to one clause.
+ *
+ * Three rules fire here rather than in the component. A value patch that crosses one/many promotes or
+ * demotes the operator on an enum field, which is why nobody has to think about `is any of`. An
+ * operator patch reshapes the value to the shape that operator reads. A field patch that changes the
+ * KIND resets the operator and value, because a charge threshold means nothing as a status — unless
+ * the same patch supplies its own operator or value, which is honoured instead.
+ */
+export const updateClause = (
+  clauses: Clause[],
+  id: string,
+  patch: Partial<Omit<Clause, 'id'>>,
+  schema: FilterSchema,
+): Clause[] =>
+  clauses.map((clause) => {
+    if (clause.id !== id) return clause;
+
+    if (patch.field !== undefined && patch.field !== clause.field) {
+      const from = schema[clause.field];
+      const to = schema[patch.field];
+      if (!to) return clause;
+      if (from?.kind === to.kind) {
+        const swapped = { ...clause, ...patch };
+        // An enum's vocabulary belongs to its field: carrying `FUNCTIONAL` onto Borough would leave a
+        // clause that reads complete and matches nothing. Keep only what the new field declares.
+        if (to.kind === 'enum' && patch.value === undefined && Array.isArray(swapped.value)) {
+          const declared = new Set((to.values ?? []).map((v) => v.value));
+          swapped.value = (swapped.value as string[]).filter((v) => declared.has(v));
+        }
+        return swapped;
+      }
+      return {
+        id: clause.id,
+        field: patch.field,
+        operator: patch.operator !== undefined ? patch.operator : defaultOperator(to.kind),
+        value: patch.value !== undefined ? patch.value : emptyValue(to),
+      };
+    }
+
+    const next = { ...clause, ...patch };
+
+    // An operator the author picked reshapes the value it left behind, unless the same patch says
+    // what the value should be.
+    if (patch.operator !== undefined && patch.operator !== clause.operator && patch.value === undefined) {
+      next.value = reshapeValue(clause.value, clause.operator, patch.operator);
+    }
+
+    if (
+      schema[clause.field]?.kind === 'enum' &&
+      patch.value !== undefined &&
+      patch.operator === undefined &&
+      Array.isArray(patch.value)
+    ) {
+      const many = patch.value.length > 1;
+      const moved = many ? PROMOTE[clause.operator] : DEMOTE[clause.operator];
+      if (moved) next.operator = moved;
+    }
+
+    return next;
+  });
+
+export const removeClause = (clauses: Clause[], id: string): Clause[] =>
+  clauses.filter((clause) => clause.id !== id);
+
+/**
+ * A clause with nothing in it is inert, not invalid — the predicate skips it and the chip shows a
+ * placeholder. There is no error state anywhere in the bar.
+ */
+export const isComplete = (clause: Clause): boolean => {
+  const { value } = clause;
+  if (value === null || value === undefined) return false;
+  // A range needs both ends: two finite numbers on a number field, two dates on a date field. A
+  // half-filled range stays inert rather than reaching a predicate that reads the missing end.
+  if (clause.operator === 'isBetween') {
+    if (!Array.isArray(value) || value.length !== 2) return false;
+    const [lo, hi] = value as [unknown, unknown];
+    if (typeof lo === 'number' || typeof hi === 'number') {
+      return typeof lo === 'number' && Number.isFinite(lo) && typeof hi === 'number' && Number.isFinite(hi);
+    }
+    return typeof lo === 'string' && lo.trim().length > 0 && typeof hi === 'string' && hi.trim().length > 0;
+  }
+  if (typeof value === 'boolean') return true;
+  if (typeof value === 'number') return Number.isFinite(value);
+  if (typeof value === 'string') return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return Number.isFinite(value.n) && value.n > 0;
+};
+
+const labelOf = (field: FilterField | undefined, value: string): string =>
+  field?.values?.find((v) => v.value === value)?.label ?? value;
+
+/** "statuses" from an explicit plural, else a lower-cased label with an s. */
+const pluralOf = (field: FilterField | undefined, label: string): string =>
+  field?.plural ?? `${label.toLowerCase()}s`;
+
+const withUnit = (n: number, field: FilterField | undefined): string => `${n}${field?.unit ?? ''}`;
+
+/** A date clause holds an ISO string; the chip shows it the way a reader writes it. */
+const formatDate = (iso: unknown): string => {
+  if (typeof iso !== 'string') return '';
+  const at = new Date(iso);
+  return Number.isNaN(at.getTime())
+    ? iso
+    : at.toLocaleDateString('en-GB', { day: 'numeric', month: 'short', year: 'numeric', timeZone: 'UTC' });
+};
+
+/** What the chip's value segment reads. Empty for an incomplete clause. */
+export const summariseClause = (clause: Clause, schema: FilterSchema): string => {
+  if (!isComplete(clause)) return '';
+  const field = schema[clause.field];
+  const { value } = clause;
+
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+  if (typeof value === 'string') return field?.kind === 'date' ? formatDate(value) : value;
+  if (typeof value === 'number') return withUnit(value, field);
+
+  if (Array.isArray(value)) {
+    if (clause.operator === 'isBetween') {
+      const [lo, hi] = value as [unknown, unknown];
+      if (typeof lo === 'number' && typeof hi === 'number') {
+        return `${withUnit(lo, field)} – ${withUnit(hi, field)}`;
+      }
+      return `${formatDate(lo)} – ${formatDate(hi)}`;
+    }
+    const values = value as string[];
+    // One label, then a count. Two joined labels are wider than any collapsed count, so summarising
+    // the pair would swell the chip on the second pick and snap it back on the third.
+    if (values.length <= 1) return values.map((v) => labelOf(field, v)).join(', ');
+    return `${values.length} ${pluralOf(field, field?.label ?? clause.field)}`;
+  }
+
+  // The last shape is the relative window; the guard narrows value away from null (an incomplete
+  // clause already returned '' above), which also keeps the shared vue-tsc gate at zero errors.
+  return value ? `${value.n} ${value.unit}${value.n === 1 ? '' : 's'}` : '';
+};
+
+export const findClauseByField = (clauses: Clause[], field: string): Clause | undefined =>
+  clauses.find((clause) => clause.field === field);
+
+/** Re-exported so a consumer rendering an operator menu needs one import, not two. */
+export { OPERATOR_LABEL };

package/packages/ui/src/filter/filterPredicate.ts

@@ -0,0 +1,134 @@
+// Clauses in, matching rows out.
+//
+// Dates are ISO strings compared as epoch ms. @internationalized/date is a docs dependency, not one
+// of this package's, and Date.parse already does this comparison — the CalendarDate conversion lives
+// in FFilterChip's date segment, at the UI boundary.
+import type { FilterSchema } from './filterSchema';
+import { isComplete, type Clause, type RelativeUnit } from './filterClause';
+
+const DAY_MS = 86_400_000;
+const WINDOW_MS: Record<RelativeUnit, number> = {
+  day: DAY_MS,
+  week: 7 * DAY_MS,
+  month: 30 * DAY_MS,
+};
+
+const text = (v: unknown): string => (v == null ? '' : String(v)).toLowerCase();
+
+/** NaN for anything unparseable, which then fails every comparison below. */
+const ms = (v: unknown): number => (typeof v === 'string' || v instanceof Date ? Date.parse(String(v)) : Number.NaN);
+
+// A date bound names a whole DAY — that is what the calendar picks — so the comparisons run against
+// the day's edges rather than the instant stored. Without this, "before the 20th" and "between the
+// 1st and the 20th" would each drop the rows recorded during the 20th.
+const dayStart = (v: unknown): number => {
+  const at = ms(v);
+  if (!Number.isFinite(at)) return at;
+  const on = new Date(at);
+  return Date.UTC(on.getUTCFullYear(), on.getUTCMonth(), on.getUTCDate());
+};
+
+const nextDayStart = (v: unknown): number => {
+  const at = dayStart(v);
+  return Number.isFinite(at) ? at + DAY_MS : at;
+};
+
+/**
+ * Does one row satisfy one clause? `now` is a parameter rather than a Date.now() call so the date
+ * operators are deterministic under test.
+ */
+export const matchesClause = (
+  row: Record<string, unknown>,
+  clause: Clause,
+  now: number = Date.now(),
+): boolean => {
+  const cell = row[clause.field];
+  const { value } = clause;
+
+  switch (clause.operator) {
+    case 'is':
+      if (Array.isArray(value)) return (value as string[]).includes(String(cell));
+      if (typeof value === 'boolean') return Boolean(cell) === value;
+      if (typeof value === 'number') return Number(cell) === value;
+      return text(cell) === text(value);
+
+    case 'isNot':
+      if (Array.isArray(value)) return !(value as string[]).includes(String(cell));
+      if (typeof value === 'number') return Number(cell) !== value;
+      return text(cell) !== text(value);
+
+    case 'isAnyOf':
+      return Array.isArray(value) && (value as string[]).includes(String(cell));
+
+    case 'isNoneOf':
+      return Array.isArray(value) && !(value as string[]).includes(String(cell));
+
+    case 'contains':
+      return text(cell).includes(text(value));
+
+    case 'doesNotContain':
+      return !text(cell).includes(text(value));
+
+    case 'isAbove':
+      return Number(cell) > Number(value);
+
+    case 'isBelow':
+      return Number(cell) < Number(value);
+
+    case 'isBetween': {
+      if (!Array.isArray(value)) return false;
+      const [lo, hi] = value as [unknown, unknown];
+      // One operator, two kinds: a numeric range on a number field, a date range on a date field.
+      if (typeof lo === 'number') return Number(cell) >= lo && Number(cell) <= Number(hi);
+      const at = ms(cell);
+      // Both ends are inclusive of the day they name, so a row timestamped during the last day
+      // still falls inside the range the chip reads out.
+      return at >= dayStart(lo) && at < nextDayStart(hi);
+    }
+
+    case 'isBefore':
+      return ms(cell) < dayStart(value);
+
+    case 'isAfter':
+      return ms(cell) >= nextDayStart(value);
+
+    case 'inTheLast': {
+      if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+      const { n, unit } = value as { n: number; unit: RelativeUnit };
+      const window = WINDOW_MS[unit];
+      if (!Number.isFinite(n) || window === undefined) return false;
+      const at = ms(cell);
+      return at >= now - n * window && at <= now;
+    }
+
+    default:
+      return true;
+  }
+};
+
+/**
+ * Every complete clause narrows the set; incomplete ones and clauses naming an undeclared field are
+ * skipped, so a half-built filter shows the unfiltered list rather than an empty one.
+ */
+export const applyClauses = <T extends Record<string, unknown>>(
+  rows: readonly T[],
+  clauses: readonly Clause[],
+  schema: FilterSchema,
+): T[] => {
+  const live = clauses.filter((clause) => schema[clause.field] && isComplete(clause));
+  if (!live.length) return [...rows];
+  const now = Date.now();
+  return rows.filter((row) => live.every((clause) => matchesClause(row, clause, now)));
+};
+
+/**
+ * The `{ id, value }` shape TanStack's ColumnFiltersState uses, built without importing TanStack —
+ * this package must not depend on it. Pair with a column `filterFn` that hands the row and the
+ * rebuilt clause back to matchesClause.
+ */
+export const toColumnFilters = (
+  clauses: readonly Clause[],
+): { id: string; value: unknown }[] =>
+  clauses
+    .filter(isComplete)
+    .map((clause) => ({ id: clause.field, value: { operator: clause.operator, value: clause.value } }));

package/packages/ui/src/filter/filterSchema.ts

@@ -0,0 +1,82 @@
+// What a surface declares as filterable. A field's KIND decides its operators, so adding a
+// filterable field costs one schema line and no operator wiring.
+
+/** The five shapes a filterable value comes in. */
+export type FieldKind = 'enum' | 'text' | 'number' | 'date' | 'boolean';
+
+export type Operator =
+  | 'is'
+  | 'isNot'
+  | 'isAnyOf'
+  | 'isNoneOf'
+  | 'contains'
+  | 'doesNotContain'
+  | 'isAbove'
+  | 'isBelow'
+  | 'isBetween'
+  | 'isBefore'
+  | 'isAfter'
+  | 'inTheLast';
+
+/** One selectable value of an enum field. `label` is what the picker and the chip show. */
+export interface FilterValue {
+  value: string;
+  label: string;
+  icon?: string;
+  avatar?: { src?: string; alt?: string };
+}
+
+export interface FilterField {
+  kind: FieldKind;
+  /** Singular, as it reads in the chip's first segment: "Status". */
+  label: string;
+  /** Used when the chip summarises several values: "3 statuses". Falls back to a lower-cased label. */
+  plural?: string;
+  icon?: string;
+  /** Suffixed to a number in a summary: "above 20%". */
+  unit?: string;
+  /** Required for `enum`; the picker's value list. */
+  values?: readonly FilterValue[];
+}
+
+export type FilterSchema = Record<string, FilterField>;
+
+/**
+ * The first entry of each list is that kind's default operator, so a freshly added clause reads the
+ * way it would in Linear: an enum starts at `is`, and picking a second value promotes it to `is any of`.
+ */
+export const OPERATORS_BY_KIND: Record<FieldKind, readonly Operator[]> = {
+  enum: ['is', 'isNot', 'isAnyOf', 'isNoneOf'],
+  text: ['contains', 'doesNotContain', 'is', 'isNot'],
+  number: ['is', 'isNot', 'isAbove', 'isBelow', 'isBetween'],
+  date: ['isBefore', 'isAfter', 'isBetween', 'inTheLast'],
+  boolean: ['is'],
+} as const;
+
+/** Lower case: the label reads inline between the field and the value, not as a heading. */
+export const OPERATOR_LABEL: Record<Operator, string> = {
+  is: 'is',
+  isNot: 'is not',
+  isAnyOf: 'is any of',
+  isNoneOf: 'is none of',
+  contains: 'contains',
+  doesNotContain: 'does not contain',
+  isAbove: 'is above',
+  isBelow: 'is below',
+  isBetween: 'is between',
+  isBefore: 'is before',
+  isAfter: 'is after',
+  inTheLast: 'in the last',
+};
+
+export const defaultOperator = (kind: FieldKind): Operator => OPERATORS_BY_KIND[kind][0];
+
+export const operatorsFor = (field: FilterField): readonly Operator[] => OPERATORS_BY_KIND[field.kind];
+
+/**
+ * Passing a row type as the explicit type argument constrains the schema's keys to that row's keys.
+ * Calling it without an argument accepts any keys. Identity at runtime.
+ */
+export const defineFilterSchema = <T = Record<string, FilterField>>(
+  schema: Partial<Record<keyof T & string, FilterField>>,
+): FilterSchema => schema as FilterSchema;

package/packages/ui/src/filter/index.ts

@@ -0,0 +1,36 @@
+// Forest's filter bar — one entry, matching ./map.
+//
+//   <FFilterBar>         the Linear-style bar: a row of clause chips plus an add-filter control
+//   <FFilterTrigger>     just the add-filter control, for a bar that holds nothing else
+//   <FFilterClauses>     just the applied chips, for the bar below it
+//   <FFilterChip>        one clause, rendered as a UFieldGroup (field / operator / value)
+//   defineFilterSchema() declares the filterable fields and their kinds
+//   applyClauses()       evaluates a clause list against rows
+//   OPERATORS_BY_KIND    which operators a field kind permits — the operator/value-shape pairing
+export { default as FFilterBar } from './FFilterBar.vue';
+export { default as FFilterTrigger } from './FFilterTrigger.vue';
+export { default as FFilterClauses } from './FFilterClauses.vue';
+export { default as FFilterChip } from './FFilterChip.vue';
+
+export type { FilterSlot } from './filter.theme';
+
+export {
+  OPERATORS_BY_KIND,
+  OPERATOR_LABEL,
+  defineFilterSchema,
+} from './filterSchema';
+export type {
+  FieldKind,
+  Operator,
+  FilterValue,
+  FilterField,
+  FilterSchema,
+} from './filterSchema';
+
+export {
+  addClause,
+  isComplete,
+} from './filterClause';
+export type { RelativeUnit, ClauseValue, Clause } from './filterClause';
+
+export { applyClauses, toColumnFilters } from './filterPredicate';

package/packages/ui/src/forest-preset.ts

@@ -0,0 +1,68 @@
+/**
+ * Forest preset for Nuxt UI (Vue).
+ *
+ * Pass to the `ui()` Vite plugin: `ui(forestPreset)`. Maps Forest semantic colours onto Nuxt UI
+ * roles and spreads in the per-component theme fragments (./themes). Everything is driven by the
+ * per-family OKLCH ramp vars (--<family>-50..950, light + `.dark`), so it auto-themes. The
+ * signature <UButton> emphasis ladder lives in themes/button.ts + themes/button.mechanics.ts.
+ */
+
+// Per-component Forest theme fragments — one file each in ./themes, aggregated (and aliased to the
+// Nuxt UI ui-config keys) by ./themes/index.ts. Spread into `ui` below so every override is live.
+import * as componentThemes from './themes';
+
+export const forestPreset = {
+  ui: {
+    // All per-component fragments (button with its keycap mechanics, card with its nesting marker,
+    // input with its ported FInput depth line, popover, alert, table, …) — one file per component
+    // in ./themes; this spread is the single source of component themes (asserted by the static
+    // tests). NOTE: object spread does NOT merge — a component key declared after this spread
+    // would replace its fragment wholesale, which is why it comes first and the preset declares
+    // only non-component config (icons, colors) beside it.
+    ...componentThemes,
+
+    // Icon aliases (appConfig.ui.icons). `star` is read ONLY by UInputRating (verified in the 4.10
+    // source), so pointing it at a SOLID glyph is safe and system-wide: a filled rating star reads as
+    // a solid shape, not a coloured outline of the lucide default. It uses Forest's OWN vendored star
+    // (`i-forest-star-fill`, packages/ui/icons/forest) so the app stays on lucide + forest only. The
+    // empty state falls back to this same icon rendered muted (`emptyIcon ?? starIcon`).
+    icons: {
+      star: 'i-forest-star-fill',
+    },
+    // Nuxt UI semantic roles (drive --ui-* for non-button components: badge, alert, …). Buttons
+    // override their own colours via the per-family --btn-* vars in themes/button.mechanics.ts,
+    // independent of this map.
+    // Alias contract (engine NUXT_UI_ALIASES): primary/success→forest, error→maple, info→river,
+    // warning→amber, secondary→warm, neutral→neutral. Every family is a Tailwind colour registered by
+    // the engine @theme (packages/tokens/scales/theme.css), re-pointed to the P3 OKLCH ramps at :root —
+    // so all seven roles, surfaces and text included, are the Forest engine, not stock Tailwind ramps.
+    colors: {
+      primary: 'forest',
+      secondary: 'warm',
+      success: 'forest',
+      info: 'river',
+      warning: 'amber',
+      error: 'maple',
+      neutral: 'neutral', // Forest neutral ramp — drives every surface + muted/dimmed text and borders
+    },
+  },
+
+  // Register the scale families as Nuxt UI colours (color="forest|maple|river|warm|acid").
+  // Production wiring: docs.css bridges their --ui-color-* steps to the engine ramps — the charts
+  // palette and any color="<family>" usage depend on this list. `primary` is auto-prepended by the
+  // plugin; the other default roles must be relisted here or they'd be dropped.
+  theme: {
+    // Mutable assertion: NuxtUIOptions wants Color[], and the outer `as const` would freeze this
+    // to a readonly tuple.
+    colors: ['secondary', 'success', 'info', 'warning', 'error', 'forest', 'maple', 'river', 'warm', 'acid'] as string[],
+  },
+} as const;
+
+/**
+ * Marker classes the CORE preset stamps for its own structural CSS (styles/forest.css consumers).
+ * These are context-free — no manifest claims them; the census allowlists them and still requires
+ * a live CSS consumer for each.
+ */
+export const PRESET_STRUCTURAL_MARKERS = ['forest-card'] as const;
+
+export default forestPreset;