@wrdagency/blockout 0.1.10 → 1.0.0

package/dist/components/data-form/autosave.d.ts

@@ -0,0 +1,4 @@
+import { FormStore, FormValues } from './types';
+export declare function useAutoSave<T extends FormValues>(onSubmit: ((values: T) => void | Promise<void>) | undefined, store: FormStore<T>, enabled: boolean): {
+    ref: import('react').RefObject<HTMLFormElement>;
+};

package/dist/components/data-form/autosave.js

@@ -0,0 +1,12 @@
+import { noop as t } from "../../utils/noop.js";
+import { c } from "../../index-D7vLJIGX.js";
+import { useRef as n, useEffect as i } from "react";
+function a(u = t, e, o) {
+  const f = n(null), r = c(e.values, 2e3);
+  return i(() => {
+    o && e.checkValidity() && e.save(u);
+  }, [r, o]), { ref: f };
+}
+export {
+  a as useAutoSave
+};

package/dist/components/data-form/context.d.ts

@@ -0,0 +1,10 @@
+import { PropsWithChildren } from 'react';
+import { FormStore, FormValues } from './types';
+type DataFormContext<T extends FormValues> = {
+    store: FormStore<T>;
+};
+export declare const useDataForm: <T extends FormValues>() => DataFormContext<T>;
+export declare const Provider: <T extends FormValues>({ children, store, }: PropsWithChildren<{
+    store: FormStore<T>;
+}>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-form/context.js

@@ -0,0 +1,10 @@
+import { jsx as e } from "react/jsx-runtime";
+import { createContext as n, useContext as s } from "react";
+const o = n(void 0), a = () => s(o), c = ({
+  children: r,
+  store: t
+}) => /* @__PURE__ */ e(o.Provider, { value: { store: t }, children: r });
+export {
+  c as Provider,
+  a as useDataForm
+};

package/dist/components/data-form/form.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, PropsWithChildren } from 'react';
+import { FormStore, FormValues } from './types';
+interface FormProps<T extends FormValues> extends PropsWithChildren {
+    className?: string;
+    onSubmit?: (values: T) => void | Promise<void>;
+    store: FormStore<T>;
+    autoSave?: boolean;
+    style?: CSSProperties;
+}
+export declare const Form: <T extends FormValues>({ className, onSubmit, store, autoSave, children, style, }: FormProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-form/form.js

@@ -0,0 +1,30 @@
+import { jsx as m } from "react/jsx-runtime";
+import { cn as c } from "../../utils/css.js";
+import { noop as s } from "../../utils/noop.js";
+import { useAutoSave as l } from "./autosave.js";
+import { Provider as d } from "./context.js";
+const S = ({
+  className: t,
+  onSubmit: r = s,
+  store: o,
+  autoSave: e = !1,
+  children: n,
+  style: a
+}) => {
+  const { ref: f } = l(r, o, e), i = async (p) => {
+    p.preventDefault(), o.reportValidity() && o.save(r);
+  };
+  return /* @__PURE__ */ m(d, { store: o, children: /* @__PURE__ */ m(
+    "form",
+    {
+      className: c("component-data-form", t),
+      onSubmit: i,
+      ref: f,
+      style: a,
+      children: n
+    }
+  ) });
+};
+export {
+  S as Form
+};

package/dist/components/data-form/index.js

@@ -0,0 +1,14 @@
+import { createFormStore as o } from "./api.js";
+import { Form as r } from "./form.js";
+import { Row as t } from "./row.js";
+import { Status as m } from "./status.js";
+import { Submit as e } from "./submit.js";
+import '../../assets/index5.css';const s = Object.assign(r, {
+  Row: t,
+  Submit: e,
+  Status: m,
+  createStore: o
+});
+export {
+  s as DataForm
+};

package/dist/components/data-form/row.d.ts

@@ -0,0 +1,7 @@
+import { FC, PropsWithChildren } from 'react';
+interface RowProps extends PropsWithChildren {
+    className?: string;
+    tight?: boolean;
+}
+export declare const Row: FC<RowProps>;
+export {};

package/dist/components/data-form/row.js

@@ -0,0 +1,16 @@
+import { jsx as m } from "react/jsx-runtime";
+import { cn as a } from "../../utils/css.js";
+const c = ({ className: o, tight: r = !1, children: t }) => /* @__PURE__ */ m(
+  "div",
+  {
+    className: a(
+      "component-data-form__row",
+      r && "component-data-form__row--tight",
+      o
+    ),
+    children: t
+  }
+);
+export {
+  c as Row
+};

package/dist/components/data-form/status.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+interface StatusProps {
+    className?: string;
+}
+export declare const Status: FC<StatusProps>;
+export {};

package/dist/components/data-form/status.js

@@ -0,0 +1,37 @@
+import { jsxs as r, jsx as i } from "react/jsx-runtime";
+import { cn as e } from "../../utils/css.js";
+import '../../assets/styles.css';import '../../assets/style6.css';import '../../assets/style5.css';import '../../assets/style4.css';import '../../assets/style3.css';import '../../assets/style2.css';import '../../assets/style.css';import '../../assets/style9.css';/* empty css                   */
+import "react";
+/* empty css                   */
+/* empty css                   */
+import "../../primitives/popover/index.js";
+/* empty css                   */
+import "../../primitives/scroll-area/index.js";
+import { Symbol as a } from "../../primitives/symbol/index.js";
+/* empty css                   */
+/* empty css                   */
+/* empty css                   */
+/* empty css                    */
+import { useDataForm as p } from "./context.js";
+const _ = ({ className: m }) => {
+  const { store: s } = p(), { status: t, lastSaved: o } = s;
+  return /* @__PURE__ */ r("div", { className: e("component-data-form__status", m), children: [
+    /* @__PURE__ */ i(
+      a.Progress,
+      {
+        stage: t === "clean" ? "suceeded" : t === "dirty" ? "to-do" : "pending"
+      }
+    ),
+    t === "saving" ? /* @__PURE__ */ i("span", { children: "Saving..." }) : /* @__PURE__ */ r("span", { children: [
+      "Last saved:",
+      " ",
+      o ? o.toLocaleTimeString(void 0, {
+        timeStyle: "short",
+        hourCycle: "h24"
+      }) : "never"
+    ] })
+  ] });
+};
+export {
+  _ as Status
+};

package/dist/components/data-form/submit.d.ts

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from 'react';
+import { ButtonProps } from '../button/button';
+interface SubmitProps extends PropsWithChildren {
+    variant?: ButtonProps["variant"];
+    size?: ButtonProps["size"];
+    wide?: ButtonProps["wide"];
+    className?: string;
+}
+export declare const Submit: FC<SubmitProps>;
+export {};

package/dist/components/data-form/submit.js

@@ -0,0 +1,37 @@
+import { jsx as i } from "react/jsx-runtime";
+import { cn as a } from "../../utils/css.js";
+import '../../assets/styles.css';import '../../assets/style6.css';import '../../assets/style5.css';import '../../assets/style3.css';import '../../assets/style2.css';import '../../assets/style.css';import '../../assets/style9.css';/* empty css                   */
+import "react";
+/* empty css                   */
+/* empty css                   */
+import "../../primitives/popover/index.js";
+/* empty css                   */
+import "../../primitives/scroll-area/index.js";
+import "../../primitives/symbol/index.js";
+import { Tooltip as e } from "../../primitives/tooltip/index.js";
+/* empty css                   */
+/* empty css                   */
+/* empty css                    */
+import { Button as p } from "../button/index.js";
+import { useDataForm as n } from "./context.js";
+const C = ({
+  className: t,
+  children: m,
+  ...s
+}) => {
+  const { store: o } = n(), r = o.isClean ? "You haven't made any changes yet." : o.hasErrors ? "There are errors in your submission." : o.isSaving ? "Saving..." : void 0;
+  return /* @__PURE__ */ i(e, { label: r, children: /* @__PURE__ */ i(
+    p,
+    {
+      className: a("component-data-form__submit", t),
+      disabled: !!r,
+      "aria-busy": o.isSaving,
+      type: "submit",
+      ...s,
+      children: m
+    }
+  ) });
+};
+export {
+  C as Submit
+};

package/dist/components/data-form/types.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export type FormValues = Record<string, any>;
+export type FormStatus = "clean" | "dirty" | "saving";
+export type FormErrors<T extends FormValues> = Partial<Record<keyof T, string>>;
+export type Setter<T> = (newValue: T | ((previousValues: T) => T)) => void;
+export type ControlProps<T extends any> = {
+    value: T;
+    onChangeValue: (newValue: T) => void;
+    onBlur: () => void;
+    help?: string;
+    "aria-invalid"?: boolean;
+};
+export type FormStore<T extends FormValues> = {
+    status: FormStatus;
+    lastSaved: Date | null;
+    isDirty: boolean;
+    isClean: boolean;
+    isSaving: boolean;
+    values: T;
+    setValues: Setter<Partial<T>>;
+    errors: FormErrors<T>;
+    hasErrors: boolean;
+    checkValidity: () => boolean;
+    reportValidity: () => boolean;
+    validation: {
+        [K in keyof T]: z.ZodType<T[K], any, any>;
+    };
+    defaults: T;
+    control: <K extends keyof T>(key: K) => ControlProps<T[K]>;
+    save: (callback: (values: T) => Promise<void> | void) => void;
+};
+export type FormStoreOpts<T extends FormValues> = {
+    validation: {
+        [K in keyof T]: z.ZodType<T[K], any, any>;
+    };
+    defaults: T;
+};

package/dist/components/data-form/types.js

@@ -0,0 +1 @@
+

package/dist/components/data-view/api.d.ts

@@ -0,0 +1,24 @@
+import { Field, PartialField, PartialView, View } from './types';
+import { Action, PartialAction } from './types/actions';
+import { HierarchyDefinition } from './types/hierarchy';
+export declare function useSchema<TData extends object = object>(schema: PartialSchema<TData>): Schema<TData>;
+export type PartialSchema<TData extends object = object> = {
+    primaryKey: keyof TData;
+    fields: PartialField<TData>[];
+    hierarchy?: HierarchyDefinition<TData>;
+    actions?: PartialAction<TData>[];
+};
+export type Schema<TData extends object = object> = {
+    primaryKey: keyof TData;
+    fields: Field<TData>[];
+    hierarchy?: HierarchyDefinition<TData>;
+    actions: Action<TData>[];
+};
+export type UseViewOpts = {
+    initial?: PartialView;
+    saveKey?: string;
+};
+export declare function useView(opts?: UseViewOpts): {
+    readonly view: View;
+    readonly setView: import('react').Dispatch<import('react').SetStateAction<View>>;
+};

package/dist/components/data-view/api.js

@@ -0,0 +1,31 @@
+import { u as a } from "../../index-D7vLJIGX.js";
+import { useMemo as s, useState as l } from "react";
+import { normalizeField as u, normalizeAction as c, normalizeView as f } from "./data/normalize.js";
+function d(i) {
+  const e = s(
+    () => i.fields.map(u),
+    [i.fields]
+  ), t = s(
+    () => (i.actions || []).map(c),
+    [i.actions]
+  );
+  return {
+    ...i,
+    actions: t,
+    fields: e
+  };
+}
+function V(i = {}) {
+  const { initial: e = {}, saveKey: t } = i, r = s(() => f(e), [e]);
+  if (t) {
+    const [o, n] = a(t, r);
+    return { view: o, setView: n };
+  } else {
+    const [o, n] = l(r);
+    return { view: o, setView: n };
+  }
+}
+export {
+  d as useSchema,
+  V as useView
+};

package/dist/components/data-view/data/apply.d.ts

@@ -0,0 +1,10 @@
+import { DataGroup, Field, Filter, SortDirection, View } from '../types';
+import { HierarchyDefinition } from '../types/hierarchy';
+export declare function applyFiltering<TData extends object = object>(data: TData[], fields: Field<TData>[], filters: Filter[]): TData[];
+export declare function applySearching<TData extends object = object>(data: TData[], fields: Field<TData>[], query: string): TData[];
+export declare function applyGrouping<TData extends object = object>(data: TData[], fields: Field<TData>[], groupBy: string | false, includeEmptyGroups: boolean, order: SortDirection, hierarchy: HierarchyDefinition<TData> | undefined, hideChildren: boolean): DataGroup<TData>[];
+export declare function applySorting<TData extends object = object>(data: TData[], fields: Field<TData>[], sortBy: string, order: SortDirection, isSearch: boolean): TData[];
+export declare function applyPagination<TData extends object = object>(items: TData[], view: View): TData[];
+export declare function applyGroupPagination<TData extends object = object>(groups: DataGroup<TData>[], perPage: number, page: number, totalItems: number, includeEmptyGroups: boolean): DataGroup<TData>[];
+export declare function applyHierarchy<TData extends object = object>(groups: DataGroup<TData>[], hierarchy: HierarchyDefinition<TData> | undefined, primaryKey: keyof TData, hideChildren: boolean): DataGroup<TData>[];
+export declare function useApplyView<TData extends object = object>(data: TData[], fields: Field<TData>[], view: View, hiearchy: HierarchyDefinition<TData> | undefined, primaryKey: keyof TData): DataGroup<TData>[];

package/dist/components/data-view/data/apply.js

@@ -0,0 +1,346 @@
+import { b as H } from "../../../sortable.esm-De3H-_AA.js";
+import { g as J } from "../../../_commonjsHelpers-C6fGbg64.js";
+import { useMemo as L } from "react";
+var V = {}, q = {}, G;
+function D() {
+  return G || (G = 1, function(e) {
+    e.__esModule = !0, e.default = y;
+    var a = /[\u0300-\u036f]/g, r = /ł/g, d = /ñ/g;
+    function y(s) {
+      return s.toLowerCase().normalize("NFD").replace(a, "").replace(r, "l").replace(d, "n").trim();
+    }
+  }(q)), q;
+}
+var C = {}, W;
+function A() {
+  if (W) return C;
+  W = 1, C.__esModule = !0, C.aggressiveFuzzyMatch = g, C.createFuzzySearchImpl = E, C.experimentalSmartFuzzyMatch = l, C.fuzzyMatchImpl = S;
+  var e = a(D());
+  function a(n) {
+    return n && n.__esModule ? n : { default: n };
+  }
+  var r = Number.MAX_SAFE_INTEGER, d = function(t, f) {
+    return (
+      /*: number*/
+      t.score - f.score
+    );
+  }, y = function(t, f) {
+    return (
+      /*: number*/
+      t[0] - f[0]
+    );
+  }, s = new Set(`  []()-–—'"“”`.split(""));
+  function u(n) {
+    return s.has(n);
+  }
+  function i(n, t, f, F, o, m, p) {
+    if (n === F)
+      return [0, [[0, n.length - 1]]];
+    var c = F.length, v = t.length, x = o.length;
+    if (t === o)
+      return [0.1, [[0, v - 1]]];
+    if (t.startsWith(o))
+      return [0.5, [[0, x - 1]]];
+    var M = n.indexOf(F);
+    if (M > -1 && u(n[M - 1]))
+      return [0.9, [[M, M + c - 1]]];
+    var z = t.indexOf(o);
+    if (z > -1 && u(t[z - 1]))
+      return [1, [[z, z + c - 1]]];
+    var T = m.length;
+    if (T > 1 && m.every(function(k) {
+      return f.has(k);
+    })) {
+      var _ = 1.5 + T * 0.2;
+      return [_, m.map(function(k) {
+        var b = t.indexOf(k);
+        return [b, b + k.length - 1];
+      }).sort(y)];
+    }
+    return z > -1 ? [2, [[z, z + c - 1]]] : p === "aggressive" ? g(t, o) : p === "smart" ? l(t, o) : null;
+  }
+  function g(n, t) {
+    for (var f = n.length, F = t.length, o = 0, m = t[o], p = [], c = -1, v = -2, x = 0; x < f; x += 1)
+      if (n[x] === m) {
+        if (x !== v + 1 && (c >= 0 && p.push([c, v]), c = x), v = x, o += 1, o === F)
+          return p.push([c, v]), h(p, n);
+        m = t[o];
+      }
+    return null;
+  }
+  function l(n, t) {
+    for (var f = n.length, F = [], o = 0, m = t[o], p = -1, c = -2; ; ) {
+      var v = n.indexOf(m, c + 1);
+      if (v === -1)
+        break;
+      if (v === 0 || u(n[v - 1]))
+        p = v;
+      else {
+        var x = t.length - o, M = n.length - v, z = Math.min(3, x, M), T = t.slice(o, o + z);
+        if (n.slice(v, v + z) === T)
+          p = v;
+        else {
+          c += 1;
+          continue;
+        }
+      }
+      for (c = p; c < f && n[c] === m; c += 1)
+        o += 1, m = t[o];
+      if (c -= 1, F.push([p, c]), o === t.length)
+        return h(F, n);
+    }
+    return null;
+  }
+  function h(n, t) {
+    var f = 2;
+    return n.forEach(function(F) {
+      var o = F[0], m = F[1], p = m - o + 1, c = o === 0 || t[o] === " " || t[o - 1] === " ", v = m === t.length - 1 || t[m] === " " || t[m + 1] === " ", x = c && v;
+      x ? f += 0.2 : c ? f += 0.4 : p >= 3 ? f += 0.8 : f += 1.6;
+    }), [f, n];
+  }
+  function S(n, t) {
+    var f = (0, e.default)(t), F = f.split(" "), o = (0, e.default)(n), m = new Set(o.split(" ")), p = i(n, o, m, t, f, F, "smart");
+    return p ? {
+      item: n,
+      score: p[0],
+      matches: [p[1]]
+    } : null;
+  }
+  function E(n, t) {
+    var f = t.strategy, F = f === void 0 ? "aggressive" : f, o = t.getText, m = n.map(function(p) {
+      var c;
+      if (o)
+        c = o(p);
+      else {
+        var v = t.key ? p[t.key] : p;
+        c = [v];
+      }
+      var x = c.map(function(M) {
+        var z = M || "", T = (0, e.default)(z), _ = new Set(T.split(" "));
+        return [z, T, _];
+      });
+      return [p, x];
+    });
+    return function(p) {
+      var c = [], v = (0, e.default)(p), x = v.split(" ");
+      return v.length ? (m.forEach(function(M) {
+        for (var z = M[0], T = M[1], _ = r, k = [], b = 0, P = T.length; b < P; b += 1) {
+          var O = T[b], N = O[0], I = O[1], X = O[2], R = i(N, I, X, p, v, x, F);
+          R ? (_ = Math.min(_, R[0]), k.push(R[1])) : k.push(null);
+        }
+        _ < r && c.push({
+          item: z,
+          score: _,
+          matches: k
+        });
+      }), c.sort(d), c) : [];
+    };
+  }
+  return C;
+}
+var B;
+function U() {
+  return B || (B = 1, function(e) {
+    e.__esModule = !0, e.default = d, e.fuzzyMatch = y;
+    var a = r(D());
+    e.normalizeText = a.default;
+    function r(s) {
+      return s && s.__esModule ? s : { default: s };
+    }
+    function d(s, u) {
+      return u === void 0 && (u = {}), A().createFuzzySearchImpl(s, u);
+    }
+    function y(s, u) {
+      return A().fuzzyMatchImpl(s, u);
+    }
+  }(V)), V;
+}
+var Y = U();
+const Z = /* @__PURE__ */ J(Y);
+function $(e, a, r) {
+  return r.length ? e.filter((d) => {
+    for (const y of r) {
+      const s = a.find((l) => l.id === y.field);
+      if (!s)
+        continue;
+      const u = s.getValue(d), i = s.filtering.types.find(
+        (l) => l.id === y.type
+      );
+      if (!i)
+        continue;
+      if (!i.filterFn(u, y.value))
+        return !1;
+    }
+    return !0;
+  }) : e;
+}
+function K(e, a, r) {
+  if (!r)
+    return e;
+  const d = a.filter((u) => u.filtering.searchable);
+  return Z(e, {
+    getText: (u) => d.map((i) => String(i.getValue(u)))
+  })(r).map((u) => u.item);
+}
+function j(e, a, r, d, y, s, u) {
+  const i = r ? a.find((h) => h.id === r) : !1;
+  if (!i || !i.sorting.groupable)
+    return [
+      {
+        id: "all",
+        label: "All",
+        items: e
+      }
+    ];
+  const g = /* @__PURE__ */ new Map();
+  for (const h of i.elements) {
+    const S = h.value;
+    g.set(h.value, {
+      id: S,
+      label: h.label,
+      icon: h.icon,
+      items: []
+    });
+  }
+  for (const h of e) {
+    if (u && s && s.hasParent(h))
+      continue;
+    const S = i.getValue(h), E = i.sorting.groupFn(S), n = Array.isArray(E) ? E : [E];
+    for (const t of n) {
+      const f = g.get(t);
+      if (f)
+        g.set(t, {
+          ...f,
+          items: [...f.items, h]
+        });
+      else {
+        const F = i.sorting.labelFn(S);
+        g.set(t, {
+          id: t,
+          label: F,
+          items: [h]
+        });
+      }
+    }
+  }
+  let l = [...g.values()];
+  return d || (l = l.filter((h) => h.items.length > 0)), i.sorting.sortable ? l.sort((h, S) => i.sorting.sortFn(h.id, S.id, y)) : l;
+}
+function Q(e, a, r, d, y) {
+  if (y)
+    return e;
+  const s = a.find((u) => u.id === r);
+  return !s || !s.sorting.sortable ? e : [...e].sort((u, i) => {
+    const g = s.getValue(u), l = s.getValue(i);
+    return s.sorting.sortFn(g, l, d);
+  });
+}
+function sr(e, a) {
+  return e.slice((a.page - 1) * a.perPage, a.page * a.perPage);
+}
+function w(e, a, r, d, y) {
+  if (d <= a)
+    return e;
+  let s = [], u = a * (r - 1), i = 0;
+  for (const g of e) {
+    if (u > g.items.length) {
+      u -= g.items.length, s.push({
+        ...g,
+        items: []
+      });
+      continue;
+    }
+    const l = a - i, h = g.items.slice(u, u + l);
+    i += h.length, u -= u, s.push({
+      ...g,
+      items: h
+    });
+  }
+  return y || (s = s.filter((g) => g.items.length > 0)), s;
+}
+function rr(e, a, r, d) {
+  if (!a)
+    return e;
+  const { getParent: y, hasParent: s } = a, u = e.map((i) => i.items).flat();
+  for (const i of e) {
+    d && (i.items = i.items.filter((l) => !s(l)));
+    const g = i.items.map((l) => ({
+      item: l,
+      parent: s(l) ? y({ item: l, items: u }) : void 0
+    })).filter((l) => !!l.parent);
+    for (const l of g) {
+      const { parent: h, item: S } = l, E = i.items.findIndex(
+        (t) => t[r] === S[r]
+      ), n = i.items.findIndex(
+        (t) => t[r] === h[r]
+      );
+      E < 0 || n < 0 || (i.items = H(i.items, E, n + 1));
+    }
+  }
+  return e;
+}
+function ur(e, a, r, d, y) {
+  const s = L(
+    () => $(e, a, r.filters),
+    [e, a, r.filters]
+  ), u = L(
+    () => K(s, a, r.search),
+    [s, a, r.search]
+  ), i = L(
+    () => Q(
+      u,
+      a,
+      r.sortBy,
+      r.sortOrder,
+      !!r.search
+    ),
+    [u, a, r.sortBy, r.sortOrder, !!r.search]
+  ), g = L(
+    () => j(
+      i,
+      a,
+      r.groupBy,
+      r.includeEmptyGroups,
+      r.groupOrder,
+      d,
+      r.relationships !== "full"
+    ),
+    [
+      i,
+      a,
+      r.groupBy,
+      r.includeEmptyGroups,
+      r.groupOrder,
+      d,
+      r.relationships
+    ]
+  ), l = L(
+    () => w(
+      g,
+      r.perPage,
+      r.page,
+      e.length,
+      r.includeEmptyGroups
+    ),
+    [g, r.perPage, r.page, e.length, r.includeEmptyGroups]
+  );
+  return L(
+    () => rr(
+      l,
+      d,
+      y,
+      r.relationships !== "full"
+    ),
+    [l, d, y, r.relationships]
+  );
+}
+export {
+  $ as applyFiltering,
+  w as applyGroupPagination,
+  j as applyGrouping,
+  rr as applyHierarchy,
+  sr as applyPagination,
+  K as applySearching,
+  Q as applySorting,
+  ur as useApplyView
+};

package/dist/components/data-view/data/fields.d.ts

@@ -0,0 +1,4 @@
+import { Field, MultiplePlacement, SingularPlacement, View } from '../types';
+export declare function isFieldVisible(field: Field<any>, view: View): boolean;
+export declare function getPlacement<TData extends object = object>(placement: SingularPlacement, fields: Field<TData>[], view: View): Field<TData> | undefined;
+export declare function getPlacements<TData extends object = object>(placement: MultiplePlacement, fields: Field<TData>[], view: View): Field<TData>[];