@oicl/openbridge-webcomponents-full-bundle 2.0.0-next.70 → 2.0.0-next.71

package/custom-elements.json

@@ -63955,6 +63955,100 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/textbox/textbox.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "`<obc-textbox>` – A text container that renders inline text at a\nprecise, cap-height-trimmed size with configurable alignment and reservable\nwidth.\n\nUse it to present short, read-only strings – such as values, labels, or\nunits – where vertical metrics must line up exactly across rows and the\nhorizontal footprint should stay stable while the text changes (for example\na numeric value that updates frequently). Synonyms: text container, value\nbox, label box.\n\n## Features / Variants\n- **Size:** `xs`, `s`, `m` (default), `l`, `xl` – each maps to a fixed box\n  height (16 / 20 / 24 / 32 / 40 px) with 4px padding above and below, giving\n  cap heights of 8 / 12 / 16 / 24 / 32 px so text aligns to a predictable\n  grid.\n- **Font weight:** `regular` (default), `semibold`, `bold`.\n- **Alignment:** `left`, `center`, `right` (default) – positions the text\n  within the box's width when the box is wider than the content.\n- **Reserved width:** content placed in the `length` slot reserves a minimum\n  width invisibly, so the box does not resize as the visible text changes.\n  The box always shows all content – it never crops.\n\n## Usage Guidelines\n- Pass the longest expected string to the `length` slot (e.g. `\"888.8\"` or\n  `\"Wind speed\"`) so the box reserves space and does not jump in width as the\n  visible value updates.\n- This is a display primitive for static text – use an input component for\n  editable values.\n\n## Slots\n| Slot      | Renders when…      | Purpose                                              |\n|-----------|--------------------|------------------------------------------------------|\n| (default) | Always             | The visible text content.                            |\n| `length`  | Always (invisible) | Reserves a minimum width based on its content width. |",
+          "name": "ObcTextbox",
+          "slots": [
+            {
+              "description": "The visible text content.",
+              "name": ""
+            },
+            {
+              "description": "Reserves a minimum width based on its content width.",
+              "name": "length"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "alignment",
+              "type": {
+                "text": "ObcTextboxAlignment"
+              },
+              "attribute": "alignment"
+            },
+            {
+              "kind": "field",
+              "name": "size",
+              "type": {
+                "text": "ObcTextboxSize"
+              },
+              "attribute": "size"
+            },
+            {
+              "kind": "field",
+              "name": "fontWeight",
+              "type": {
+                "text": "ObcTextboxFontWeight"
+              },
+              "attribute": "fontWeight"
+            }
+          ],
+          "attributes": [
+            {
+              "name": "alignment",
+              "type": {
+                "text": "ObcTextboxAlignment"
+              },
+              "fieldName": "alignment"
+            },
+            {
+              "name": "size",
+              "type": {
+                "text": "ObcTextboxSize"
+              },
+              "fieldName": "size"
+            },
+            {
+              "name": "fontWeight",
+              "type": {
+                "text": "ObcTextboxFontWeight"
+              },
+              "fieldName": "fontWeight"
+            }
+          ],
+          "superclass": {
+            "name": "LitElement",
+            "package": "lit"
+          },
+          "tagName": "obc-textbox",
+          "customElement": true
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "ObcTextbox",
+          "declaration": {
+            "name": "ObcTextbox",
+            "module": "src/components/textbox/textbox.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "obc-textbox",
+          "declaration": {
+            "name": "ObcTextbox",
+            "module": "src/components/textbox/textbox.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/components/title-container/title-container.ts",

package/dist/components/textbox/textbox.css.js

@@ -0,0 +1,114 @@
+import { css } from "lit";
+const componentStyle = css`
+          * {
+            -webkit-tap-highlight-color: transparent;
+          }
+
+:host {
+  display: inline-block;
+  line-height: 0;
+}
+
+.wrapper {
+  display: inline-flex;
+  flex-direction: column;
+  width: fit-content;
+  --height: 24px;
+  --padding: 4px;
+  font-family: var(--font-family-main);
+  letter-spacing: var(--global-typography-generic-l-letter-spacing);
+}
+
+/* The inner-wrapper is the box: its height (--height) is the full textbox
+   height, padding included. The content is sized to the cap height and
+   vertically centered, which leaves the padding as equal space above and
+   below. In engines that support text-box-trim the content box collapses to
+   the cap height exactly; in Firefox (no text-box-trim) the content keeps its
+   natural line box, so align-items:center + overflow:hidden crops it to the
+   same height instead. No padding here – the centering provides it.
+   (A small top padding could be added later to nudge the text up in Firefox.) */
+
+.inner-wrapper {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: var(--alignment-justify, flex-end);
+  height: var(--height);
+  overflow: hidden;
+}
+
+/* The spacer must share the content's exact font metrics so the width it
+   reserves equals the rendered content width. font-size-adjust scales the
+   font, so it has to match too. */
+
+.content,
+.length-spacer {
+  font-size: calc(var(--height) - 2 * var(--padding));
+  font-size-adjust: cap-height 1;
+  white-space: nowrap;
+}
+
+.content {
+  text-box-trim: trim-both;
+  text-box-edge: cap alphabetic;
+}
+
+.wrapper.size-xs .inner-wrapper {
+  --height: 16px;
+}
+
+.wrapper.size-s .inner-wrapper {
+  --height: 20px;
+}
+
+.wrapper.size-m .inner-wrapper {
+  --height: 24px;
+}
+
+.wrapper.size-l .inner-wrapper {
+  --height: 32px;
+}
+
+.wrapper.size-xl .inner-wrapper {
+  --height: 40px;
+}
+
+.wrapper.font-weight-regular {
+  font-weight: var(--global-typography-generic-l-font-weight-regular);
+}
+
+.wrapper.font-weight-semibold {
+  font-weight: var(--global-typography-generic-l-font-weight-medium);
+}
+
+.wrapper.font-weight-bold {
+  font-weight: var(--global-typography-generic-l-font-weight-bold);
+}
+
+.wrapper.alignment-left {
+  --alignment-justify: flex-start;
+}
+
+.wrapper.alignment-center {
+  --alignment-justify: center;
+}
+
+.wrapper.alignment-right {
+  --alignment-justify: flex-end;
+}
+
+/* Reserves the box width from the \`length\` slot without occupying vertical
+   space. Acts as a minimum width so the box does not resize as visible
+   text changes. */
+
+.length-spacer {
+  height: 0;
+  opacity: 0;
+  visibility: hidden;
+  overflow: hidden;
+}
+`;
+export {
+  componentStyle as default
+};
+//# sourceMappingURL=textbox.css.js.map

package/dist/components/textbox/textbox.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textbox.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/textbox/textbox.d.ts

@@ -0,0 +1,70 @@
+import { LitElement } from 'lit';
+export declare enum ObcTextboxAlignment {
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}
+export declare enum ObcTextboxSize {
+    xs = "xs",
+    s = "s",
+    m = "m",
+    l = "l",
+    xl = "xl"
+}
+export declare enum ObcTextboxFontWeight {
+    regular = "regular",
+    semibold = "semibold",
+    bold = "bold"
+}
+/**
+ * `<obc-textbox>` – A text container that renders inline text at a
+ * precise, cap-height-trimmed size with configurable alignment and reservable
+ * width.
+ *
+ * Use it to present short, read-only strings – such as values, labels, or
+ * units – where vertical metrics must line up exactly across rows and the
+ * horizontal footprint should stay stable while the text changes (for example
+ * a numeric value that updates frequently). Synonyms: text container, value
+ * box, label box.
+ *
+ * ## Features / Variants
+ * - **Size:** `xs`, `s`, `m` (default), `l`, `xl` – each maps to a fixed box
+ *   height (16 / 20 / 24 / 32 / 40 px) with 4px padding above and below, giving
+ *   cap heights of 8 / 12 / 16 / 24 / 32 px so text aligns to a predictable
+ *   grid.
+ * - **Font weight:** `regular` (default), `semibold`, `bold`.
+ * - **Alignment:** `left`, `center`, `right` (default) – positions the text
+ *   within the box's width when the box is wider than the content.
+ * - **Reserved width:** content placed in the `length` slot reserves a minimum
+ *   width invisibly, so the box does not resize as the visible text changes.
+ *   The box always shows all content – it never crops.
+ *
+ * ## Usage Guidelines
+ * - Pass the longest expected string to the `length` slot (e.g. `"888.8"` or
+ *   `"Wind speed"`) so the box reserves space and does not jump in width as the
+ *   visible value updates.
+ * - This is a display primitive for static text – use an input component for
+ *   editable values.
+ *
+ * ## Slots
+ * | Slot      | Renders when…      | Purpose                                              |
+ * |-----------|--------------------|------------------------------------------------------|
+ * | (default) | Always             | The visible text content.                            |
+ * | `length`  | Always (invisible) | Reserves a minimum width based on its content width. |
+ *
+ * @slot - The visible text content.
+ * @slot length - Reserves a minimum width based on its content width.
+ */
+export declare class ObcTextbox extends LitElement {
+    alignment: ObcTextboxAlignment;
+    size: ObcTextboxSize;
+    fontWeight: ObcTextboxFontWeight;
+    render(): import('lit-html').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'obc-textbox': ObcTextbox;
+    }
+}
+//# sourceMappingURL=textbox.d.ts.map

package/dist/components/textbox/textbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textbox.d.ts","sourceRoot":"","sources":["../../../src/components/textbox/textbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAkB,MAAM,KAAK,CAAC;AAMhD,oBAAY,mBAAmB;IAC7B,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,KAAK,UAAU;CAChB;AAED,oBAAY,cAAc;IACxB,EAAE,OAAO;IACT,CAAC,MAAM;IACP,CAAC,MAAM;IACP,CAAC,MAAM;IACP,EAAE,OAAO;CACV;AAED,oBAAY,oBAAoB;IAC9B,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBACa,UAAW,SAAQ,UAAU;IACd,SAAS,EAAE,mBAAmB,CAC5B;IACF,IAAI,EAAE,cAAc,CAAoB;IACxC,UAAU,EAAE,oBAAoB,CAC3B;IAEtB,MAAM;IAsBf,OAAgB,MAAM,0BAA6B;CACpD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,aAAa,EAAE,UAAU,CAAC;KAC3B;CACF"}

package/dist/components/textbox/textbox.js

@@ -0,0 +1,84 @@
+import { unsafeCSS, LitElement, html } from "lit";
+import { customElement } from "../../decorator.js";
+import componentStyle from "./textbox.css.js";
+import { property } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var ObcTextboxAlignment = /* @__PURE__ */ ((ObcTextboxAlignment2) => {
+  ObcTextboxAlignment2["Left"] = "left";
+  ObcTextboxAlignment2["Center"] = "center";
+  ObcTextboxAlignment2["Right"] = "right";
+  return ObcTextboxAlignment2;
+})(ObcTextboxAlignment || {});
+var ObcTextboxSize = /* @__PURE__ */ ((ObcTextboxSize2) => {
+  ObcTextboxSize2["xs"] = "xs";
+  ObcTextboxSize2["s"] = "s";
+  ObcTextboxSize2["m"] = "m";
+  ObcTextboxSize2["l"] = "l";
+  ObcTextboxSize2["xl"] = "xl";
+  return ObcTextboxSize2;
+})(ObcTextboxSize || {});
+var ObcTextboxFontWeight = /* @__PURE__ */ ((ObcTextboxFontWeight2) => {
+  ObcTextboxFontWeight2["regular"] = "regular";
+  ObcTextboxFontWeight2["semibold"] = "semibold";
+  ObcTextboxFontWeight2["bold"] = "bold";
+  return ObcTextboxFontWeight2;
+})(ObcTextboxFontWeight || {});
+let ObcTextbox = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.alignment = "right";
+    this.size = "m";
+    this.fontWeight = "regular";
+  }
+  render() {
+    return html`
+      <div
+        class=${classMap({
+      wrapper: true,
+      [`alignment-${this.alignment}`]: true,
+      [`size-${this.size}`]: true,
+      [`font-weight-${this.fontWeight}`]: true
+    })}
+      >
+        <div class="inner-wrapper">
+          <div class="content">
+            <slot></slot>
+          </div>
+        </div>
+        <div class="length-spacer" aria-hidden="true">
+          <slot name="length"></slot>
+        </div>
+      </div>
+    `;
+  }
+};
+ObcTextbox.styles = unsafeCSS(componentStyle);
+__decorateClass([
+  property({ type: String })
+], ObcTextbox.prototype, "alignment", 2);
+__decorateClass([
+  property({ type: String })
+], ObcTextbox.prototype, "size", 2);
+__decorateClass([
+  property({ type: String })
+], ObcTextbox.prototype, "fontWeight", 2);
+ObcTextbox = __decorateClass([
+  customElement("obc-textbox")
+], ObcTextbox);
+export {
+  ObcTextbox,
+  ObcTextboxAlignment,
+  ObcTextboxFontWeight,
+  ObcTextboxSize
+};
+//# sourceMappingURL=textbox.js.map

package/dist/components/textbox/textbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textbox.js","sources":["../../../src/components/textbox/textbox.ts"],"sourcesContent":["import {LitElement, html, unsafeCSS} from 'lit';\nimport {customElement} from '../../decorator.js';\nimport componentStyle from './textbox.css?inline';\nimport {property} from 'lit/decorators.js';\nimport {classMap} from 'lit/directives/class-map.js';\n\nexport enum ObcTextboxAlignment {\n  Left = 'left',\n  Center = 'center',\n  Right = 'right',\n}\n\nexport enum ObcTextboxSize {\n  xs = 'xs',\n  s = 's',\n  m = 'm',\n  l = 'l',\n  xl = 'xl',\n}\n\nexport enum ObcTextboxFontWeight {\n  regular = 'regular',\n  semibold = 'semibold',\n  bold = 'bold',\n}\n\n/**\n * `<obc-textbox>` – A text container that renders inline text at a\n * precise, cap-height-trimmed size with configurable alignment and reservable\n * width.\n *\n * Use it to present short, read-only strings – such as values, labels, or\n * units – where vertical metrics must line up exactly across rows and the\n * horizontal footprint should stay stable while the text changes (for example\n * a numeric value that updates frequently). Synonyms: text container, value\n * box, label box.\n *\n * ## Features / Variants\n * - **Size:** `xs`, `s`, `m` (default), `l`, `xl` – each maps to a fixed box\n *   height (16 / 20 / 24 / 32 / 40 px) with 4px padding above and below, giving\n *   cap heights of 8 / 12 / 16 / 24 / 32 px so text aligns to a predictable\n *   grid.\n * - **Font weight:** `regular` (default), `semibold`, `bold`.\n * - **Alignment:** `left`, `center`, `right` (default) – positions the text\n *   within the box's width when the box is wider than the content.\n * - **Reserved width:** content placed in the `length` slot reserves a minimum\n *   width invisibly, so the box does not resize as the visible text changes.\n *   The box always shows all content – it never crops.\n *\n * ## Usage Guidelines\n * - Pass the longest expected string to the `length` slot (e.g. `\"888.8\"` or\n *   `\"Wind speed\"`) so the box reserves space and does not jump in width as the\n *   visible value updates.\n * - This is a display primitive for static text – use an input component for\n *   editable values.\n *\n * ## Slots\n * | Slot      | Renders when…      | Purpose                                              |\n * |-----------|--------------------|------------------------------------------------------|\n * | (default) | Always             | The visible text content.                            |\n * | `length`  | Always (invisible) | Reserves a minimum width based on its content width. |\n *\n * @slot - The visible text content.\n * @slot length - Reserves a minimum width based on its content width.\n */\n@customElement('obc-textbox')\nexport class ObcTextbox extends LitElement {\n  @property({type: String}) alignment: ObcTextboxAlignment =\n    ObcTextboxAlignment.Right;\n  @property({type: String}) size: ObcTextboxSize = ObcTextboxSize.m;\n  @property({type: String}) fontWeight: ObcTextboxFontWeight =\n    ObcTextboxFontWeight.regular;\n\n  override render() {\n    return html`\n      <div\n        class=${classMap({\n          wrapper: true,\n          [`alignment-${this.alignment}`]: true,\n          [`size-${this.size}`]: true,\n          [`font-weight-${this.fontWeight}`]: true,\n        })}\n      >\n        <div class=\"inner-wrapper\">\n          <div class=\"content\">\n            <slot></slot>\n          </div>\n        </div>\n        <div class=\"length-spacer\" aria-hidden=\"true\">\n          <slot name=\"length\"></slot>\n        </div>\n      </div>\n    `;\n  }\n\n  static override styles = unsafeCSS(componentStyle);\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'obc-textbox': ObcTextbox;\n  }\n}\n"],"names":["ObcTextboxAlignment","ObcTextboxSize","ObcTextboxFontWeight"],"mappings":";;;;;;;;;;;;;;;AAMO,IAAK,wCAAAA,yBAAL;AACLA,uBAAA,MAAA,IAAO;AACPA,uBAAA,QAAA,IAAS;AACTA,uBAAA,OAAA,IAAQ;AAHE,SAAAA;AAAA,GAAA,uBAAA,CAAA,CAAA;AAML,IAAK,mCAAAC,oBAAL;AACLA,kBAAA,IAAA,IAAK;AACLA,kBAAA,GAAA,IAAI;AACJA,kBAAA,GAAA,IAAI;AACJA,kBAAA,GAAA,IAAI;AACJA,kBAAA,IAAA,IAAK;AALK,SAAAA;AAAA,GAAA,kBAAA,CAAA,CAAA;AAQL,IAAK,yCAAAC,0BAAL;AACLA,wBAAA,SAAA,IAAU;AACVA,wBAAA,UAAA,IAAW;AACXA,wBAAA,MAAA,IAAO;AAHG,SAAAA;AAAA,GAAA,wBAAA,CAAA,CAAA;AA8CL,IAAM,aAAN,cAAyB,WAAW;AAAA,EAApC,cAAA;AAAA,UAAA,GAAA,SAAA;AACqB,SAAA,YACxB;AACwB,SAAA,OAAuB;AACvB,SAAA,aACxB;AAAA,EAAA;AAAA,EAEO,SAAS;AAChB,WAAO;AAAA;AAAA,gBAEK,SAAS;AAAA,MACf,SAAS;AAAA,MACT,CAAC,aAAa,KAAK,SAAS,EAAE,GAAG;AAAA,MACjC,CAAC,QAAQ,KAAK,IAAI,EAAE,GAAG;AAAA,MACvB,CAAC,eAAe,KAAK,UAAU,EAAE,GAAG;AAAA,IAAA,CACrC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYR;AAGF;AA9Ba,WA6BK,SAAS,UAAU,cAAc;AA5BvB,gBAAA;AAAA,EAAzB,SAAS,EAAC,MAAM,OAAA,CAAO;AAAA,GADb,WACe,WAAA,aAAA,CAAA;AAEA,gBAAA;AAAA,EAAzB,SAAS,EAAC,MAAM,OAAA,CAAO;AAAA,GAHb,WAGe,WAAA,QAAA,CAAA;AACA,gBAAA;AAAA,EAAzB,SAAS,EAAC,MAAM,OAAA,CAAO;AAAA,GAJb,WAIe,WAAA,cAAA,CAAA;AAJf,aAAN,gBAAA;AAAA,EADN,cAAc,aAAa;AAAA,GACf,UAAA;"}

package/eslint.config.mjs

@@ -301,16 +301,11 @@ const openbridgePlugin = {
                   p.key.type === 'Identifier' &&
                   p.key.name === 'attribute'
               );
-            const isBuildingBlock =
-              typeof context.filename === 'string' &&
-              context.filename.includes('building-blocks');
             if (property?.value?.value === false) {
               return;
             }
-            let message = 'Prefer boolean property default values of false';
-            if (isBuildingBlock) {
-              message += ' or set Attribute: false on the property decorator';
-            }
+            let message =
+              'Prefer boolean property default values of false or set attribute: false on the property decorator';
             context.report({
               node,
               message,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oicl/openbridge-webcomponents-full-bundle",
-  "version": "2.0.0-next.70",
+  "version": "2.0.0-next.71",
   "type": "module",
   "repository": {
     "type": "git",

package/src/components/textbox/textbox.css

@@ -0,0 +1,100 @@
+:host {
+  display: inline-block;
+  line-height: 0;
+}
+
+.wrapper {
+  display: inline-flex;
+  flex-direction: column;
+  width: fit-content;
+  --height: 24px;
+  --padding: 4px;
+  font-family: var(--font-family-main);
+  letter-spacing: var(--global-typography-generic-l-letter-spacing);
+}
+
+/* The inner-wrapper is the box: its height (--height) is the full textbox
+   height, padding included. The content is sized to the cap height and
+   vertically centered, which leaves the padding as equal space above and
+   below. In engines that support text-box-trim the content box collapses to
+   the cap height exactly; in Firefox (no text-box-trim) the content keeps its
+   natural line box, so align-items:center + overflow:hidden crops it to the
+   same height instead. No padding here – the centering provides it.
+   (A small top padding could be added later to nudge the text up in Firefox.) */
+.inner-wrapper {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: var(--alignment-justify, flex-end);
+  height: var(--height);
+  overflow: hidden;
+}
+
+/* The spacer must share the content's exact font metrics so the width it
+   reserves equals the rendered content width. font-size-adjust scales the
+   font, so it has to match too. */
+.content,
+.length-spacer {
+  font-size: calc(var(--height) - 2 * var(--padding));
+  font-size-adjust: cap-height 1;
+  white-space: nowrap;
+}
+
+.content {
+  text-box-trim: trim-both;
+  text-box-edge: cap alphabetic;
+}
+
+.wrapper.size-xs .inner-wrapper {
+  --height: 16px;
+}
+
+.wrapper.size-s .inner-wrapper {
+  --height: 20px;
+}
+
+.wrapper.size-m .inner-wrapper {
+  --height: 24px;
+}
+
+.wrapper.size-l .inner-wrapper {
+  --height: 32px;
+}
+
+.wrapper.size-xl .inner-wrapper {
+  --height: 40px;
+}
+
+.wrapper.font-weight-regular {
+  font-weight: var(--global-typography-generic-l-font-weight-regular);
+}
+
+.wrapper.font-weight-semibold {
+  font-weight: var(--global-typography-generic-l-font-weight-medium);
+}
+
+.wrapper.font-weight-bold {
+  font-weight: var(--global-typography-generic-l-font-weight-bold);
+}
+
+.wrapper.alignment-left {
+  --alignment-justify: flex-start;
+}
+
+.wrapper.alignment-center {
+  --alignment-justify: center;
+}
+
+.wrapper.alignment-right {
+  --alignment-justify: flex-end;
+}
+
+/* Reserves the box width from the `length` slot without occupying vertical
+   space. Acts as a minimum width so the box does not resize as visible
+   text changes. */
+.length-spacer {
+  height: 0;
+  opacity: 0;
+  visibility: hidden;
+  overflow: hidden;
+}

package/src/components/textbox/textbox.stories.ts

@@ -0,0 +1,165 @@
+import type {Meta, StoryObj} from '@storybook/web-components-vite';
+import {
+  ObcTextbox,
+  ObcTextboxAlignment,
+  ObcTextboxFontWeight,
+  ObcTextboxSize,
+} from './textbox.js';
+import './textbox.js';
+import {html} from 'lit';
+
+interface TextboxStoryArgs extends Partial<ObcTextbox> {
+  content: string;
+  length: string;
+}
+
+const meta: Meta<TextboxStoryArgs> = {
+  title: 'Building Blocks/Textbox',
+  tags: ['autodocs', '6.0'],
+  component: 'obc-textbox',
+  args: {
+    size: ObcTextboxSize.m,
+    fontWeight: ObcTextboxFontWeight.regular,
+    alignment: ObcTextboxAlignment.Right,
+    content: '123 ABC',
+    length: '1234567 ABC',
+  },
+  argTypes: {
+    size: {
+      control: {type: 'radio'},
+      options: Object.values(ObcTextboxSize),
+    },
+    fontWeight: {
+      control: {type: 'radio'},
+      options: Object.values(ObcTextboxFontWeight),
+    },
+    alignment: {
+      control: {type: 'radio'},
+      options: Object.values(ObcTextboxAlignment),
+    },
+  },
+  render: (args) => html`
+    <obc-textbox
+      .size=${args.size}
+      .fontWeight=${args.fontWeight}
+      .alignment=${args.alignment}
+    >
+      <div>${args.content}</div>
+      <div slot="length">${args.length}</div>
+    </obc-textbox>
+  `,
+};
+
+export default meta;
+type Story = StoryObj<TextboxStoryArgs>;
+
+const labelStyle =
+  'font-size: 12px; color: var(--element-neutral-color, #777);';
+const captionStyle =
+  'font-size: 11px; font-style: italic; max-width: 520px; color: var(--element-neutral-color, #777);';
+const boxOutline = 'outline: 1px solid var(--border-outline-color);';
+
+export const Default: Story = {};
+
+export const Sizes: Story = {
+  render: () => html`
+    <div
+      style="display: flex; flex-direction: column; align-items: flex-start; gap: 16px;"
+    >
+      ${Object.values(ObcTextboxSize).map(
+        (size) => html`
+          <obc-textbox .size=${size}>
+            <div>${size.toUpperCase()} – 123 ABC</div>
+          </obc-textbox>
+        `
+      )}
+    </div>
+  `,
+};
+
+export const FontWeights: Story = {
+  render: () => html`
+    <div
+      style="display: flex; flex-direction: column; align-items: flex-start; gap: 16px;"
+    >
+      ${Object.values(ObcTextboxFontWeight).map(
+        (fontWeight) => html`
+          <obc-textbox .fontWeight=${fontWeight}>
+            <div>${fontWeight} – 123 ABC</div>
+          </obc-textbox>
+        `
+      )}
+    </div>
+  `,
+};
+
+export const Alignments: Story = {
+  render: (args) => html`
+    <div
+      style="display: flex; flex-direction: column; align-items: flex-start; gap: 16px;"
+    >
+      <div style=${captionStyle}>
+        Alignment positions the content within the box when the box is wider
+        than the content. The width is determined by whichever is wider: the
+        visible content or the reserved length slot.
+      </div>
+      ${Object.values(ObcTextboxAlignment).map(
+        (alignment) => html`
+          <div style="display: flex; align-items: center; gap: 12px;">
+            <div style="${labelStyle} width: 56px;">${alignment}</div>
+            <obc-textbox
+              .size=${args.size}
+              .fontWeight=${args.fontWeight}
+              .alignment=${alignment}
+              style=${boxOutline}
+            >
+              <div>${args.content}</div>
+              <div slot="length">${args.length}</div>
+            </obc-textbox>
+          </div>
+        `
+      )}
+    </div>
+  `,
+};
+
+export const ReserveSpace: Story = {
+  args: {
+    content: '5',
+    length: '00000',
+  },
+  render: (args) => html`
+    <div
+      style="display: flex; flex-direction: column; align-items: flex-start; gap: 16px;"
+    >
+      <div style=${captionStyle}>
+        Content placed in the length slot reserves width invisibly, so the box
+        keeps the size of the longest expected value (here "${args.length}")
+        even when the visible content is shorter.
+      </div>
+      <div style="display: flex; align-items: center; gap: 12px;">
+        <div style="${labelStyle} width: 104px;">no length slot</div>
+        <obc-textbox
+          .size=${args.size}
+          .fontWeight=${args.fontWeight}
+          .alignment=${args.alignment}
+          style=${boxOutline}
+        >
+          <div>${args.content}</div>
+        </obc-textbox>
+      </div>
+      <div style="display: flex; align-items: center; gap: 12px;">
+        <div style="${labelStyle} width: 104px;">length: ${args.length}</div>
+        <obc-textbox
+          .size=${args.size}
+          .fontWeight=${args.fontWeight}
+          .alignment=${args.alignment}
+          style=${boxOutline}
+        >
+          <div>${args.content}</div>
+          <div slot="length">${args.length}</div>
+        </obc-textbox>
+      </div>
+    </div>
+  `,
+};