@dbcdk/react-components 0.0.169 → 0.0.171

package/dist/components/datetime-picker/dateTimeHelpers.cjs

@@ -0,0 +1,185 @@
+'use strict';
+
+const RANGE_SEP_RE = /\s*(?:–|\bto\b|\btil\b|\s-\s)\s*/i;
+function normalizeSpaces(s) {
+  return s.trim().replace(/\s+/g, " ");
+}
+function splitDigitOnlyRangeParts(input) {
+  const m = /^\s*(\d{8})\s*-\s*(\d{8})\s*$/.exec(input);
+  if (!m) return null;
+  return [m[1], m[2]];
+}
+function splitRangeParts(input) {
+  var _a;
+  const digitOnly = splitDigitOnlyRangeParts(input);
+  if (digitOnly) return digitOnly;
+  const txt = normalizeSpaces(input);
+  const parts = txt.split(RANGE_SEP_RE);
+  if (parts.length < 2) return null;
+  const left = ((_a = parts[0]) != null ? _a : "").trim();
+  const right = parts.slice(1).join(" ").trim();
+  if (!left || !right) return null;
+  return [left, right];
+}
+const digits = (s) => (s.match(/\d/g) || []).join("");
+function maskDateEU(text) {
+  const d = digits(text).slice(0, 8);
+  const dd = d.slice(0, 2);
+  const mm = d.slice(2, 4);
+  const yyyy = d.slice(4, 8);
+  let out = dd;
+  if (mm.length) out += (out ? "-" : "") + mm;
+  if (yyyy.length) out += (out ? "-" : "") + yyyy;
+  return out;
+}
+function maskTimeHM(text) {
+  const d = digits(text).slice(0, 4);
+  const hh = d.slice(0, 2);
+  const mm = d.slice(2, 4);
+  return mm.length ? `${hh}:${mm}` : hh;
+}
+function maskSingle(text, enableTime) {
+  const t = normalizeSpaces(text);
+  if (!enableTime) return maskDateEU(t);
+  const m = /^(.*?)[ T](.*)$/.exec(t);
+  if (!m) {
+    const d = digits(t);
+    if (d.length <= 8) return maskDateEU(t);
+    const datePart2 = maskDateEU(d.slice(0, 8));
+    const timePart2 = maskTimeHM(d.slice(8));
+    return timePart2 ? `${datePart2} ${timePart2}` : datePart2;
+  }
+  const datePart = maskDateEU(m[1]);
+  const timePart = maskTimeHM(m[2]);
+  return timePart ? `${datePart} ${timePart}` : datePart;
+}
+function maskRange(text, _enableTime) {
+  const parts = splitRangeParts(text);
+  if (!parts) return maskSingle(text, false);
+  const [left, right] = parts;
+  const a = maskSingle(left, false);
+  const b = maskSingle(right, false);
+  return `${a} \u2013 ${b}`.trim();
+}
+const pad2 = (n) => String(n).padStart(2, "0");
+function isUtcIsoString(v) {
+  return typeof v === "string" && /Z$/.test(v) && !Number.isNaN(Date.parse(v));
+}
+function isDateOnlyString(v) {
+  if (typeof v !== "string") return false;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(v);
+  if (!m) return false;
+  const y = +m[1];
+  const mo = +m[2];
+  const d = +m[3];
+  if (mo < 1 || mo > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const local = new Date(y, mo - 1, d, 0, 0, 0, 0);
+  return local.getFullYear() === y && local.getMonth() === mo - 1 && local.getDate() === d;
+}
+function utcMillisFromIso(iso) {
+  return Date.parse(iso);
+}
+function isoFromLocalDate(dLocal) {
+  return dLocal.toISOString();
+}
+function isoFromLocalParts(y, m0, d, hh = 0, mm = 0) {
+  const local = new Date(y, m0, d, hh, mm, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== m0 || local.getDate() !== d || local.getHours() !== hh || local.getMinutes() !== mm) {
+    return null;
+  }
+  return local.toISOString();
+}
+function localDateFromIso(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return null;
+  return new Date(ms);
+}
+function dateOnlyFromLocalParts(y, m0, d) {
+  return `${String(y).padStart(4, "0")}-${pad2(m0 + 1)}-${pad2(d)}`;
+}
+function localDateFromDateOnly(s) {
+  if (!isDateOnlyString(s)) return null;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!m) return null;
+  const y = +m[1];
+  const mo0 = +m[2] - 1;
+  const d = +m[3];
+  const local = new Date(y, mo0, d, 0, 0, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== mo0 || local.getDate() !== d) return null;
+  return local;
+}
+function compareDateOnly(a, b) {
+  const da = localDateFromDateOnly(a);
+  const db = localDateFromDateOnly(b);
+  if (!da || !db) return 0;
+  const ta = Date.UTC(da.getFullYear(), da.getMonth(), da.getDate());
+  const tb = Date.UTC(db.getFullYear(), db.getMonth(), db.getDate());
+  return ta - tb;
+}
+function toMaskedFromDate(d, enableTime) {
+  const dd = pad2(d.getDate());
+  const mm = pad2(d.getMonth() + 1);
+  const yyyy = String(d.getFullYear());
+  let out = `${dd}-${mm}-${yyyy}`;
+  if (enableTime) out += ` ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+  return out;
+}
+function parseLooseDateOrDateTime(input) {
+  const txt = normalizeSpaces(input);
+  const dateTimeMatch = /^(?<date>[\d./-]{8,10})(?:[ T](?<hh>\d{1,2}):(?<mm>\d{2}))?$/i.exec(txt);
+  if (!(dateTimeMatch == null ? void 0 : dateTimeMatch.groups)) return null;
+  const raw = dateTimeMatch.groups.date;
+  const hh = dateTimeMatch.groups.hh ? parseInt(dateTimeMatch.groups.hh, 10) : 0;
+  const mm = dateTimeMatch.groups.mm ? parseInt(dateTimeMatch.groups.mm, 10) : 0;
+  if (hh < 0 || hh > 23 || mm < 0 || mm > 59) return null;
+  let y, m, d;
+  const mIso = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(raw);
+  if (mIso) {
+    y = +mIso[1];
+    m = +mIso[2] - 1;
+    d = +mIso[3];
+  } else {
+    const mEu = /^(\d{2})[./-](\d{2})[./-](\d{4})$/.exec(raw);
+    if (!mEu) return null;
+    d = +mEu[1];
+    m = +mEu[2] - 1;
+    y = +mEu[3];
+  }
+  const local = new Date(y, m, d, hh, mm, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== m || local.getDate() !== d || local.getHours() !== hh || local.getMinutes() !== mm) {
+    return null;
+  }
+  return local;
+}
+function parseLooseRange(input) {
+  const parts = splitRangeParts(input);
+  if (!parts) return null;
+  const [a, b] = parts;
+  const s = parseLooseDateOrDateTime(a);
+  const e = parseLooseDateOrDateTime(b);
+  if (!s || !e) return null;
+  return s <= e ? { start: s, end: e } : { start: e, end: s };
+}
+
+exports.compareDateOnly = compareDateOnly;
+exports.dateOnlyFromLocalParts = dateOnlyFromLocalParts;
+exports.digits = digits;
+exports.isDateOnlyString = isDateOnlyString;
+exports.isUtcIsoString = isUtcIsoString;
+exports.isoFromLocalDate = isoFromLocalDate;
+exports.isoFromLocalParts = isoFromLocalParts;
+exports.localDateFromDateOnly = localDateFromDateOnly;
+exports.localDateFromIso = localDateFromIso;
+exports.maskDateEU = maskDateEU;
+exports.maskRange = maskRange;
+exports.maskSingle = maskSingle;
+exports.maskTimeHM = maskTimeHM;
+exports.pad2 = pad2;
+exports.parseLooseDateOrDateTime = parseLooseDateOrDateTime;
+exports.parseLooseRange = parseLooseRange;
+exports.toMaskedFromDate = toMaskedFromDate;
+exports.utcMillisFromIso = utcMillisFromIso;

package/dist/components/datetime-picker/dateTimeHelpers.d.ts

@@ -0,0 +1,37 @@
+export declare const digits: (s: string) => string;
+export declare function maskDateEU(text: string): string;
+export declare function maskTimeHM(text: string): string;
+export declare function maskSingle(text: string, enableTime: boolean): string;
+export declare function maskRange(text: string, _enableTime: boolean): string;
+export declare const pad2: (n: number) => string;
+export type UtcIsoString = string;
+export type DateOnlyString = string;
+export declare function isUtcIsoString(v: unknown): v is UtcIsoString;
+export declare function isDateOnlyString(v: unknown): v is DateOnlyString;
+export declare function utcMillisFromIso(iso: UtcIsoString): number;
+/** Convert a local DateTime to a UTC ISO string (Z). */
+export declare function isoFromLocalDate(dLocal: Date): UtcIsoString;
+/**
+ * Build a *local* Date from y/m/d/hh/mm and return UTC ISO string (Z).
+ * This keeps the UI meaning "local wall time", while emitting a stable UTC instant.
+ *
+ * DST NOTE:
+ * If the requested local wall time does not exist (spring-forward), JS will auto-correct.
+ * We detect that and return null so caller can handle it (e.g., show validation error).
+ */
+export declare function isoFromLocalParts(y: number, m0: number, // 0-based
+d: number, hh?: number, mm?: number): UtcIsoString | null;
+/** For anchoring the calendar safely from a UTC ISO string. */
+export declare function localDateFromIso(iso: UtcIsoString): Date | null;
+/** Date-only: build 'YYYY-MM-DD' from local parts */
+export declare function dateOnlyFromLocalParts(y: number, m0: number, d: number): DateOnlyString;
+/** Parse 'YYYY-MM-DD' into a local Date at midnight */
+export declare function localDateFromDateOnly(s: DateOnlyString): Date | null;
+/** Compare date-only strings by UTC date-only time (stable ordering) */
+export declare function compareDateOnly(a: DateOnlyString, b: DateOnlyString): number;
+export declare function toMaskedFromDate(d: Date, enableTime: boolean): string;
+export declare function parseLooseDateOrDateTime(input: string): Date | null;
+export declare function parseLooseRange(input: string): {
+    start: Date;
+    end: Date;
+} | null;

package/dist/components/datetime-picker/dateTimeHelpers.js

@@ -0,0 +1,166 @@
+const RANGE_SEP_RE = /\s*(?:–|\bto\b|\btil\b|\s-\s)\s*/i;
+function normalizeSpaces(s) {
+  return s.trim().replace(/\s+/g, " ");
+}
+function splitDigitOnlyRangeParts(input) {
+  const m = /^\s*(\d{8})\s*-\s*(\d{8})\s*$/.exec(input);
+  if (!m) return null;
+  return [m[1], m[2]];
+}
+function splitRangeParts(input) {
+  var _a;
+  const digitOnly = splitDigitOnlyRangeParts(input);
+  if (digitOnly) return digitOnly;
+  const txt = normalizeSpaces(input);
+  const parts = txt.split(RANGE_SEP_RE);
+  if (parts.length < 2) return null;
+  const left = ((_a = parts[0]) != null ? _a : "").trim();
+  const right = parts.slice(1).join(" ").trim();
+  if (!left || !right) return null;
+  return [left, right];
+}
+const digits = (s) => (s.match(/\d/g) || []).join("");
+function maskDateEU(text) {
+  const d = digits(text).slice(0, 8);
+  const dd = d.slice(0, 2);
+  const mm = d.slice(2, 4);
+  const yyyy = d.slice(4, 8);
+  let out = dd;
+  if (mm.length) out += (out ? "-" : "") + mm;
+  if (yyyy.length) out += (out ? "-" : "") + yyyy;
+  return out;
+}
+function maskTimeHM(text) {
+  const d = digits(text).slice(0, 4);
+  const hh = d.slice(0, 2);
+  const mm = d.slice(2, 4);
+  return mm.length ? `${hh}:${mm}` : hh;
+}
+function maskSingle(text, enableTime) {
+  const t = normalizeSpaces(text);
+  if (!enableTime) return maskDateEU(t);
+  const m = /^(.*?)[ T](.*)$/.exec(t);
+  if (!m) {
+    const d = digits(t);
+    if (d.length <= 8) return maskDateEU(t);
+    const datePart2 = maskDateEU(d.slice(0, 8));
+    const timePart2 = maskTimeHM(d.slice(8));
+    return timePart2 ? `${datePart2} ${timePart2}` : datePart2;
+  }
+  const datePart = maskDateEU(m[1]);
+  const timePart = maskTimeHM(m[2]);
+  return timePart ? `${datePart} ${timePart}` : datePart;
+}
+function maskRange(text, _enableTime) {
+  const parts = splitRangeParts(text);
+  if (!parts) return maskSingle(text, false);
+  const [left, right] = parts;
+  const a = maskSingle(left, false);
+  const b = maskSingle(right, false);
+  return `${a} \u2013 ${b}`.trim();
+}
+const pad2 = (n) => String(n).padStart(2, "0");
+function isUtcIsoString(v) {
+  return typeof v === "string" && /Z$/.test(v) && !Number.isNaN(Date.parse(v));
+}
+function isDateOnlyString(v) {
+  if (typeof v !== "string") return false;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(v);
+  if (!m) return false;
+  const y = +m[1];
+  const mo = +m[2];
+  const d = +m[3];
+  if (mo < 1 || mo > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const local = new Date(y, mo - 1, d, 0, 0, 0, 0);
+  return local.getFullYear() === y && local.getMonth() === mo - 1 && local.getDate() === d;
+}
+function utcMillisFromIso(iso) {
+  return Date.parse(iso);
+}
+function isoFromLocalDate(dLocal) {
+  return dLocal.toISOString();
+}
+function isoFromLocalParts(y, m0, d, hh = 0, mm = 0) {
+  const local = new Date(y, m0, d, hh, mm, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== m0 || local.getDate() !== d || local.getHours() !== hh || local.getMinutes() !== mm) {
+    return null;
+  }
+  return local.toISOString();
+}
+function localDateFromIso(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return null;
+  return new Date(ms);
+}
+function dateOnlyFromLocalParts(y, m0, d) {
+  return `${String(y).padStart(4, "0")}-${pad2(m0 + 1)}-${pad2(d)}`;
+}
+function localDateFromDateOnly(s) {
+  if (!isDateOnlyString(s)) return null;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!m) return null;
+  const y = +m[1];
+  const mo0 = +m[2] - 1;
+  const d = +m[3];
+  const local = new Date(y, mo0, d, 0, 0, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== mo0 || local.getDate() !== d) return null;
+  return local;
+}
+function compareDateOnly(a, b) {
+  const da = localDateFromDateOnly(a);
+  const db = localDateFromDateOnly(b);
+  if (!da || !db) return 0;
+  const ta = Date.UTC(da.getFullYear(), da.getMonth(), da.getDate());
+  const tb = Date.UTC(db.getFullYear(), db.getMonth(), db.getDate());
+  return ta - tb;
+}
+function toMaskedFromDate(d, enableTime) {
+  const dd = pad2(d.getDate());
+  const mm = pad2(d.getMonth() + 1);
+  const yyyy = String(d.getFullYear());
+  let out = `${dd}-${mm}-${yyyy}`;
+  if (enableTime) out += ` ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+  return out;
+}
+function parseLooseDateOrDateTime(input) {
+  const txt = normalizeSpaces(input);
+  const dateTimeMatch = /^(?<date>[\d./-]{8,10})(?:[ T](?<hh>\d{1,2}):(?<mm>\d{2}))?$/i.exec(txt);
+  if (!(dateTimeMatch == null ? void 0 : dateTimeMatch.groups)) return null;
+  const raw = dateTimeMatch.groups.date;
+  const hh = dateTimeMatch.groups.hh ? parseInt(dateTimeMatch.groups.hh, 10) : 0;
+  const mm = dateTimeMatch.groups.mm ? parseInt(dateTimeMatch.groups.mm, 10) : 0;
+  if (hh < 0 || hh > 23 || mm < 0 || mm > 59) return null;
+  let y, m, d;
+  const mIso = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(raw);
+  if (mIso) {
+    y = +mIso[1];
+    m = +mIso[2] - 1;
+    d = +mIso[3];
+  } else {
+    const mEu = /^(\d{2})[./-](\d{2})[./-](\d{4})$/.exec(raw);
+    if (!mEu) return null;
+    d = +mEu[1];
+    m = +mEu[2] - 1;
+    y = +mEu[3];
+  }
+  const local = new Date(y, m, d, hh, mm, 0, 0);
+  if (Number.isNaN(local.getTime())) return null;
+  if (local.getFullYear() !== y || local.getMonth() !== m || local.getDate() !== d || local.getHours() !== hh || local.getMinutes() !== mm) {
+    return null;
+  }
+  return local;
+}
+function parseLooseRange(input) {
+  const parts = splitRangeParts(input);
+  if (!parts) return null;
+  const [a, b] = parts;
+  const s = parseLooseDateOrDateTime(a);
+  const e = parseLooseDateOrDateTime(b);
+  if (!s || !e) return null;
+  return s <= e ? { start: s, end: e } : { start: e, end: s };
+}
+
+export { compareDateOnly, dateOnlyFromLocalParts, digits, isDateOnlyString, isUtcIsoString, isoFromLocalDate, isoFromLocalParts, localDateFromDateOnly, localDateFromIso, maskDateEU, maskRange, maskSingle, maskTimeHM, pad2, parseLooseDateOrDateTime, parseLooseRange, toMaskedFromDate, utcMillisFromIso };

package/dist/components/divider/Divider.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+
+const spacingMap = {
+  sm: "var(--spacing-sm)",
+  md: "var(--spacing-md)",
+  lg: "var(--spacing-lg)"
+};
+const Divider = ({ spacing = "md" }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        borderTop: "1px solid var(--color-border-subtle)",
+        marginBlock: spacingMap[spacing]
+      }
+    }
+  );
+};
+
+exports.Divider = Divider;

package/dist/components/divider/Divider.d.ts

@@ -0,0 +1,5 @@
+type DividerProps = {
+    spacing?: 'sm' | 'md' | 'lg';
+};
+export declare const Divider: ({ spacing }: DividerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/divider/Divider.js

@@ -0,0 +1,20 @@
+import { jsx } from 'react/jsx-runtime';
+
+const spacingMap = {
+  sm: "var(--spacing-sm)",
+  md: "var(--spacing-md)",
+  lg: "var(--spacing-lg)"
+};
+const Divider = ({ spacing = "md" }) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        borderTop: "1px solid var(--color-border-subtle)",
+        marginBlock: spacingMap[spacing]
+      }
+    }
+  );
+};
+
+export { Divider };

package/dist/components/environment-banner/EnvironmentBanner.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var styles = require('./EnvironmentBanner.module.css');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var styles__default = /*#__PURE__*/_interopDefault(styles);
+
+const PRESETS = {
+  production: { label: "Produktionsmilj\xF8", severity: "error" },
+  staging: { label: "Staging-milj\xF8", severity: "warning" },
+  test: { label: "Test-milj\xF8", severity: "success" }
+};
+function EnvironmentBanner(props) {
+  const { label, severity } = props.environment != null ? PRESETS[props.environment] : { label: props.customLabel, severity: props.customSeverity };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: styles__default.default.banner, "data-severity": severity, role: "status", "aria-label": label, children: label });
+}
+
+exports.EnvironmentBanner = EnvironmentBanner;

package/dist/components/environment-banner/EnvironmentBanner.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from 'react';
+import type { Severity } from '../../constants/severity.types';
+export type Environment = 'production' | 'staging' | 'test';
+export type EnvironmentBannerProps = {
+    environment: Environment;
+    customLabel?: never;
+    customSeverity?: never;
+} | {
+    environment?: never;
+    customLabel: string;
+    customSeverity: Severity;
+};
+export declare function EnvironmentBanner(props: EnvironmentBannerProps): JSX.Element;

package/dist/components/environment-banner/EnvironmentBanner.js

@@ -0,0 +1,14 @@
+import { jsx } from 'react/jsx-runtime';
+import styles from './EnvironmentBanner.module.css';
+
+const PRESETS = {
+  production: { label: "Produktionsmilj\xF8", severity: "error" },
+  staging: { label: "Staging-milj\xF8", severity: "warning" },
+  test: { label: "Test-milj\xF8", severity: "success" }
+};
+function EnvironmentBanner(props) {
+  const { label, severity } = props.environment != null ? PRESETS[props.environment] : { label: props.customLabel, severity: props.customSeverity };
+  return /* @__PURE__ */ jsx("div", { className: styles.banner, "data-severity": severity, role: "status", "aria-label": label, children: label });
+}
+
+export { EnvironmentBanner };

package/dist/components/environment-banner/EnvironmentBanner.module.css

@@ -0,0 +1,54 @@
+.banner {
+  --env-banner-bg: var(--color-bg-toolbar);
+  --env-banner-fg: var(--color-fg-default);
+
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  padding-block: var(--spacing-2xs);
+  padding-inline: var(--spacing-md);
+  background-color: var(--env-banner-bg);
+  color: var(--env-banner-fg);
+  letter-spacing: var(--letter-spacing-wide);
+  font-size: var(--font-size-md);
+  font-weight: var(--font-weight-medium);
+  text-transform: uppercase;
+  line-height: var(--line-height-normal);
+  user-select: none;
+}
+
+.banner[data-severity='success'] {
+  --env-banner-bg: var(--color-status-success);
+  --env-banner-fg: var(--color-fg-on-status-success);
+}
+
+.banner[data-severity='warning'] {
+  --env-banner-bg: var(--color-status-warning);
+  --env-banner-fg: var(--color-fg-on-status-warning);
+}
+
+.banner[data-severity='error'] {
+  --env-banner-bg: var(--color-status-error);
+  --env-banner-fg: var(--color-fg-on-status-error);
+}
+
+.banner[data-severity='info'] {
+  --env-banner-bg: var(--color-status-info);
+  --env-banner-fg: var(--color-fg-on-status-info);
+}
+
+.banner[data-severity='brand'] {
+  --env-banner-bg: var(--color-brand);
+  --env-banner-fg: var(--color-fg-on-brand);
+}
+
+.banner[data-severity='accent'] {
+  --env-banner-bg: var(--color-accent);
+  --env-banner-fg: var(--color-fg-on-accent);
+}
+
+.banner[data-severity='neutral'] {
+  --env-banner-bg: var(--color-neutral);
+  --env-banner-fg: var(--color-fg-default);
+}