@norges-domstoler/dds-components 10.0.2 → 10.1.1

package/README.md

@@ -67,6 +67,9 @@ Tilgjengelige komponenter:
 - Select
 - SkipToContent
 - Spinner
+- Stack
+  - VStack
+  - HStack
 - Table
 - Tabs
 - Tag

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -1,3 +1,294 @@
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+  var exports = {},
+    Op = Object.prototype,
+    hasOwn = Op.hasOwnProperty,
+    $Symbol = "function" == typeof Symbol ? Symbol : {},
+    iteratorSymbol = $Symbol.iterator || "@@iterator",
+    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+      generator = Object.create(protoGenerator.prototype),
+      context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if ("throw" !== record.type) {
+        var result = record.arg,
+          value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+      reject(record.arg);
+    }
+    var previousPromise;
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+      return ContinueSentinel;
+    }
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+          next = function next() {
+            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+            return next.value = undefined, next.done = !0, next;
+          };
+        return next.next = next;
+      }
+    }
+    return {
+      next: doneResult
+    };
+  }
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+    for (var key in object) keys.push(key);
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+          record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+            hasFinally = hasOwn.call(entry, "finallyLoc");
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
 function _typeof(obj) {
   "@babel/helpers - typeof";
 
@@ -130,4 +421,4 @@ function _createForOfIteratorHelper(o, allowArrayLike) {
   };
 }
 
-export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _typeof as typeof, _unsupportedIterableToArray as unsupportedIterableToArray };
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _regeneratorRuntime as regeneratorRuntime, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _typeof as typeof, _unsupportedIterableToArray as unsupportedIterableToArray };

package/dist/cjs/components/Stack/Stack.d.ts

@@ -0,0 +1,37 @@
+import { stackTokens } from './Stack.tokens';
+import { BaseComponentPropsWithChildren } from '../../types';
+declare type Align = 'stretch' | 'center' | 'flex-start' | 'flex-end';
+declare type Justify = 'flex-start' | 'flex-end' | 'space-between' | 'space-around';
+export interface StackStyleProps {
+    /**
+     * Hvilken retning elementene skal plasseres i.
+     */
+    direction: 'horizontal' | 'vertical';
+    /**
+     * CSS `align-items`.
+     * @default 'center'
+     */
+    align?: Align;
+    /**
+     * CSS `justify-content`.
+     * @default 'flex-start'
+     */
+    justify?: Justify;
+    /**
+     * Hvilken spacing token som skal brukes som CSS `gap`.
+     * @default 0
+     */
+    gap?: keyof typeof stackTokens.gap | 0;
+}
+export declare type StackProps = BaseComponentPropsWithChildren<HTMLDivElement, Omit<StackStyleProps, 'direction'>>;
+export declare const HStack: import("react").ForwardRefExoticComponent<Pick<import("react").HTMLAttributes<HTMLDivElement>, "className" | "id"> & Omit<StackStyleProps, "direction"> & {
+    children?: import("react").ReactNode;
+} & {
+    htmlProps?: import("react").HTMLAttributes<HTMLDivElement> | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare const VStack: import("react").ForwardRefExoticComponent<Pick<import("react").HTMLAttributes<HTMLDivElement>, "className" | "id"> & Omit<StackStyleProps, "direction"> & {
+    children?: import("react").ReactNode;
+} & {
+    htmlProps?: import("react").HTMLAttributes<HTMLDivElement> | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/cjs/components/Stack/Stack.stories.d.ts

@@ -0,0 +1,10 @@
+import { ComponentMeta } from '@storybook/react';
+import { StackProps } from './Stack';
+declare const _default: ComponentMeta<import("react").ForwardRefExoticComponent<Pick<import("react").HTMLAttributes<HTMLDivElement>, "id" | "className"> & Omit<import("./Stack").StackStyleProps, "direction"> & {
+    children?: import("react").ReactNode;
+} & {
+    htmlProps?: import("react").HTMLAttributes<HTMLDivElement> | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>>;
+export default _default;
+export declare const VStackOverview: (args: StackProps) => JSX.Element;
+export declare const HStackOverview: (args: StackProps) => JSX.Element;

package/dist/cjs/components/Stack/Stack.tokens.d.ts

@@ -0,0 +1,20 @@
+export declare const stackTokens: {
+    gap: {
+        'local-x0.125': string;
+        'local-x0.25': string;
+        'local-x0.5': string;
+        'local-x0.75': string;
+        'local-x1': string;
+        'local-x1.5': string;
+        'local-x2': string;
+        'local-x2.5': string;
+        'local-x3': string;
+        'layout-x1': string;
+        'layout-x1.5': string;
+        'layout-x2': string;
+        'layout-x3': string;
+        'layout-x4': string;
+        'layout-x6': string;
+        'layout-x10': string;
+    };
+};

package/dist/cjs/components/Stack/index.d.ts

@@ -0,0 +1 @@
+export * from './Stack';

package/dist/cjs/components/Table/Cell.d.ts

@@ -1,10 +1,15 @@
 import { ThHTMLAttributes, TdHTMLAttributes } from 'react';
 export declare type TableCellType = 'data' | 'head';
 export declare type TableCellLayout = 'left' | 'right' | 'center' | 'text and icon';
+export declare type CollapsibleProps = {
+    isCollapsibleChild?: boolean;
+};
 export declare type TableCellProps = {
     /**Type celle. Returnerer enten `<td>` eller `<th>`. */
     type?: TableCellType;
     /**Layout av innholdet i cellen. 'tekst and icon' legger `gap` mellom barna og andre barnet i cellen.  */
     layout?: TableCellLayout;
+    /** Props ved bruk av `<CollapsibleRow>`. **OBS!** settes automatisk av forelder. */
+    collapsibleProps?: CollapsibleProps;
 } & (TdHTMLAttributes<HTMLTableCellElement> | ThHTMLAttributes<HTMLTableCellElement>);
 export declare const Cell: import("react").ForwardRefExoticComponent<TableCellProps & import("react").RefAttributes<HTMLTableCellElement>>;

package/dist/cjs/components/Table/Row.d.ts

@@ -1,23 +1,6 @@
-import { HTMLAttributes } from 'react';
-export declare type TableRowType = 'body' | 'head';
-export declare type RowMode = 'normal' | 'sum';
-export declare type TableRowProps = {
-    /**Spesifiserer om raden skal brukes i `<head>` eller `<body>`-seksjonen. */
-    type?: TableRowType;
-    /**Custom modus for rader som har ytterligere semantisk betydning (f.eks. summeringsrad), definerer kun styling. Ved bruk av sum må `<Cell>` med tall i høyrestilles vha layout prop.  */
-    mode?: RowMode;
-    /**Spesifiserer om raden har blitt valgt/markert. */
-    selected?: boolean;
-    /**Spesifiserer om raden skal ha hover styling. Brukes hovedsakelig på klikkbare rader. */
-    hoverable?: boolean;
-} & HTMLAttributes<HTMLTableRowElement>;
 export declare const Row: import("react").ForwardRefExoticComponent<{
-    /**Spesifiserer om raden skal brukes i `<head>` eller `<body>`-seksjonen. */
-    type?: TableRowType | undefined;
-    /**Custom modus for rader som har ytterligere semantisk betydning (f.eks. summeringsrad), definerer kun styling. Ved bruk av sum må `<Cell>` med tall i høyrestilles vha layout prop.  */
-    mode?: RowMode | undefined;
-    /**Spesifiserer om raden har blitt valgt/markert. */
+    type?: import("./Table.types").TableRowType | undefined;
+    mode?: import("./Table.types").RowMode | undefined;
     selected?: boolean | undefined;
-    /**Spesifiserer om raden skal ha hover styling. Brukes hovedsakelig på klikkbare rader. */
     hoverable?: boolean | undefined;
-} & HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;
+} & import("react").HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;

package/dist/cjs/components/Table/Table.d.ts

@@ -1,18 +1,6 @@
-import { HTMLAttributes } from 'react';
-export declare type TableDensity = 'normal' | 'compact';
-export declare type TableProps = {
-    /**Spesifiserer hvor romslige cellene i tabellen skal være. */
-    density?: TableDensity;
-    /**Spesifiserer om cellene i `<Head>` skal bli sticky ved scrolling. */
-    stickyHeader?: boolean;
-    /**Legger skillelinjer mellom radene. */
-    withDividers?: boolean;
-} & HTMLAttributes<HTMLTableElement>;
+import { TableDensity } from './Table.types';
 export declare const Table: import("react").ForwardRefExoticComponent<{
-    /**Spesifiserer hvor romslige cellene i tabellen skal være. */
     density?: TableDensity | undefined;
-    /**Spesifiserer om cellene i `<Head>` skal bli sticky ved scrolling. */
     stickyHeader?: boolean | undefined;
-    /**Legger skillelinjer mellom radene. */
     withDividers?: boolean | undefined;
-} & HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>>;
+} & import("react").HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>>;

package/dist/cjs/components/Table/Table.stories.d.ts

@@ -2,7 +2,7 @@ import { TableProps, SortOrder } from '.';
 declare const _default: {
     title: string;
     component: import("react").ForwardRefExoticComponent<{
-        density?: import("./Table").TableDensity | undefined;
+        density?: import("./Table.types").TableDensity | undefined;
         stickyHeader?: boolean | undefined;
         withDividers?: boolean | undefined;
     } & import("react").HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>> & {
@@ -11,8 +11,8 @@ declare const _default: {
         Body: import("react").ForwardRefExoticComponent<import("./Body").TableBodyProps & import("react").RefAttributes<HTMLTableSectionElement>>;
         Foot: import("react").ForwardRefExoticComponent<import("./Foot").TableFootProps & import("react").RefAttributes<HTMLTableSectionElement>>;
         Row: import("react").ForwardRefExoticComponent<{
-            type?: import("./Row").TableRowType | undefined;
-            mode?: import("./Row").RowMode | undefined;
+            type?: import("./Table.types").TableRowType | undefined;
+            mode?: import("./Table.types").RowMode | undefined;
             selected?: boolean | undefined;
             hoverable?: boolean | undefined;
         } & import("react").HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;
@@ -38,7 +38,7 @@ declare const _default: {
 };
 export default _default;
 export declare const Default: (args: TableProps) => JSX.Element;
-export declare const withDividers: (args: TableProps) => JSX.Element;
+export declare const WithDividers: (args: TableProps) => JSX.Element;
 export declare const Focusable: (args: TableProps) => JSX.Element;
 export declare const Compact: (args: TableProps) => JSX.Element;
 export declare const StickyHeader: (args: TableProps) => JSX.Element;

package/dist/cjs/components/Table/Table.styles.d.ts

@@ -0,0 +1,10 @@
+import { RowMode, TableRowType } from './Table.types';
+export declare const bodyRowStyles: (mode?: RowMode, selected?: boolean) => import("styled-components").FlattenSimpleInterpolation;
+declare type StyledProps = {
+    type: TableRowType;
+    mode?: RowMode;
+    selected?: boolean;
+    hoverable?: boolean;
+};
+export declare const StyledRow: import("styled-components").StyledComponent<"tr", any, StyledProps, never>;
+export {};

package/dist/cjs/components/Table/Table.tokens.d.ts

@@ -50,4 +50,9 @@ export declare const tableTokens: {
             };
         };
     };
+    collapseButton: {
+        height: string;
+        width: string;
+        borderRadius: string;
+    };
 };

package/dist/cjs/components/Table/Table.types.d.ts

@@ -0,0 +1,37 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export declare type TableDensity = 'normal' | 'compact';
+export declare type TableProps = {
+    /**Spesifiserer hvor romslige cellene i tabellen skal være. */
+    density?: TableDensity;
+    /**Spesifiserer om cellene i `<Head>` skal bli sticky ved scrolling. */
+    stickyHeader?: boolean;
+    /**Legger skillelinjer mellom radene. */
+    withDividers?: boolean;
+} & HTMLAttributes<HTMLTableElement>;
+export declare type HeaderValues = {
+    key: string;
+    content: ReactNode;
+}[];
+export declare type CollapsibleTableProps = {
+    /**Om tabellen skal kollapse. */
+    isCollapsed?: boolean;
+    /**Innhold i headere (`content`) og deres `key`. `headerValues.content` må være den samme som faktisk innhold i `<Table.Cell type='head'>`. */
+    headerValues: HeaderValues;
+    /**
+     * Indeksen(e) til kolonnen(e) som skal synes når tabellen er kollapset. Rekkefølgen i array avgjør rekkefølgen i render.
+     * @default [0]
+     *  */
+    definingColumnIndex?: number[];
+} & TableProps;
+export declare type TableRowType = 'body' | 'head';
+export declare type RowMode = 'normal' | 'sum';
+export declare type TableRowProps = {
+    /**Spesifiserer om raden skal brukes i `<head>` eller `<body>`-seksjonen. */
+    type?: TableRowType;
+    /**Custom modus for rader som har ytterligere semantisk betydning (f.eks. summeringsrad), definerer kun styling. Ved bruk av sum må `<Cell>` med tall i høyrestilles vha layout prop.  */
+    mode?: RowMode;
+    /**Spesifiserer om raden har blitt valgt/markert. */
+    selected?: boolean;
+    /**Spesifiserer om raden skal ha hover styling. Brukes hovedsakelig på klikkbare rader. */
+    hoverable?: boolean;
+} & HTMLAttributes<HTMLTableRowElement>;

package/dist/cjs/components/Table/collapsible/CollapsibleRow.d.ts

@@ -0,0 +1,6 @@
+export declare const CollapsibleRow: import("react").ForwardRefExoticComponent<{
+    type?: import("../Table.types").TableRowType | undefined;
+    mode?: import("../Table.types").RowMode | undefined;
+    selected?: boolean | undefined;
+    hoverable?: boolean | undefined;
+} & import("react").HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;

package/dist/cjs/components/Table/collapsible/CollapsibleTable.d.ts

@@ -0,0 +1,9 @@
+export declare const CollapsibleTable: import("react").ForwardRefExoticComponent<{
+    isCollapsed?: boolean | undefined;
+    headerValues: import("../Table.types").HeaderValues;
+    definingColumnIndex?: number[] | undefined;
+} & {
+    density?: import("../Table.types").TableDensity | undefined;
+    stickyHeader?: boolean | undefined;
+    withDividers?: boolean | undefined;
+} & import("react").HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>>;

package/dist/cjs/components/Table/collapsible/CollapsibleTable.stories.d.ts

@@ -0,0 +1,48 @@
+import { CollapsibleTableProps } from '..';
+declare const _default: {
+    title: string;
+    component: import("react").ForwardRefExoticComponent<{
+        isCollapsed?: boolean | undefined;
+        headerValues: import("../Table.types").HeaderValues;
+        definingColumnIndex?: number[] | undefined;
+    } & {
+        density?: import("..").TableDensity | undefined;
+        stickyHeader?: boolean | undefined;
+        withDividers?: boolean | undefined;
+    } & import("react").HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>> & {
+        Row: import("react").ForwardRefExoticComponent<{
+            type?: import("..").TableRowType | undefined;
+            mode?: import("../Table.types").RowMode | undefined;
+            selected?: boolean | undefined;
+            hoverable?: boolean | undefined;
+        } & import("react").HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;
+    };
+    argTypes: {
+        isCollapsed: {
+            control: {
+                type: string;
+            };
+        };
+        stickyHeader: {
+            control: {
+                type: string;
+            };
+        };
+    };
+    parameters: {
+        controls: {
+            exclude: string[];
+        };
+    };
+};
+export default _default;
+export declare const SingleDefiningColumn: (args: CollapsibleTableProps) => JSX.Element;
+export declare const MultipleDefiningColumns: (args: CollapsibleTableProps) => JSX.Element;
+export declare const PrioritizedDefiningColumns: (args: CollapsibleTableProps) => JSX.Element;
+export declare const withDividers: (args: CollapsibleTableProps) => JSX.Element;
+export declare const Compact: (args: CollapsibleTableProps) => JSX.Element;
+export declare const StickyHeader: (args: CollapsibleTableProps) => JSX.Element;
+export declare const WithButtonAndIcons: (args: CollapsibleTableProps) => JSX.Element;
+export declare const Responsive: (args: CollapsibleTableProps) => JSX.Element;
+export declare const ResposiveMultipleBreakpoints: (args: CollapsibleTableProps) => JSX.Element;
+export declare const Example: () => JSX.Element;

package/dist/cjs/components/Table/collapsible/Table.context.d.ts

@@ -0,0 +1,9 @@
+import { HeaderValues } from '../Table.types';
+declare type CollapsibleTableContextProps = {
+    isCollapsed?: boolean;
+    headerValues: HeaderValues;
+    definingColumnIndex: number[];
+};
+export declare const CollapsibleTableContext: import("react").Context<CollapsibleTableContextProps>;
+export declare const useCollapsibleTableContext: () => CollapsibleTableContextProps;
+export {};

package/dist/cjs/components/Table/index.d.ts

@@ -1,8 +1,11 @@
-import { Table as BaseTable, TableProps, TableDensity } from './Table';
+import { Table as BaseTable } from './Table';
+import { CollapsibleTable as BaseCollapsibleTable } from './collapsible/CollapsibleTable';
+import { TableProps, TableDensity, CollapsibleTableProps, TableRowProps, TableRowType } from './Table.types';
 import { Head, TableHeadProps } from './Head';
 import { Body, TableBodyProps } from './Body';
 import { Foot, TableFootProps } from './Foot';
-import { Row, TableRowProps, TableRowType } from './Row';
+import { Row } from './Row';
+import { CollapsibleRow } from './collapsible/CollapsibleRow';
 import { Cell, TableCellProps, TableCellLayout, TableCellType } from './Cell';
 import { SortCell, TableSortCellProps, SortOrder } from './SortCell';
 import { TableWrapper } from './TableWrapper';
@@ -16,5 +19,10 @@ declare type TableCompoundProps = typeof BaseTable & {
     SortCell: typeof SortCell;
 };
 declare const Table: TableCompoundProps;
+declare type CollapsibleTableCompoundProps = typeof BaseCollapsibleTable & {
+    Row: typeof CollapsibleRow;
+};
+declare const CollapsibleTable: CollapsibleTableCompoundProps;
 export { Table };
-export type { TableCellProps, TableDensity, TableProps, TableRowProps, TableRowType, TableHeadProps, TableBodyProps, TableFootProps, TableSortCellProps, SortOrder, TableCellLayout, TableCellType, };
+export { CollapsibleTable };
+export type { TableCellProps, TableDensity, TableProps, TableRowProps, TableRowType, TableHeadProps, TableBodyProps, TableFootProps, TableSortCellProps, SortOrder, TableCellLayout, TableCellType, CollapsibleTableProps, };

package/dist/cjs/index.d.ts

@@ -42,3 +42,6 @@ export * from './hooks';
 export * from './components/InlineEdit';
 export * from './components/TextArea';
 export * from './components/SplitButton';
+export * from './components/Stack';
+export * from './components/FormGenerator';
+export * from './components/FileUploader';