@happyvertical/smrt-manufacturing 0.53.5 → 0.53.6

package/dist/svelte/components/ProductionRunList.svelte

@@ -0,0 +1,213 @@
+<script lang="ts">
+/**
+ * ProductionRunList — production runs with their progress ("12 of 25 done")
+ * and status, and, when the host passes `oncomplete`, a field on each open run
+ * to report finished units. Presentational: the host loads runs through
+ * `ProductionRunService`, adapts them with `toProductionRunView`, and records
+ * the completion it is handed (the service checks the quantity again under
+ * its lock).
+ */
+
+import { Button, ProgressBar, StatusBadge } from '@happyvertical/smrt-ui';
+import { Form, Input } from '@happyvertical/smrt-ui/forms';
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { M } from '../i18n.js';
+import {
+  isProductionRunOpen,
+  type ProductionRunView,
+  productionRunStatusLabelKey,
+  productionRunStatusTone,
+  validateCompletionQty,
+} from '../types.js';
+
+const { t } = useI18n();
+
+/** What a host handler may return: `false` (or a throw) keeps the field as typed. */
+type HandlerResult = boolean | void | Promise<boolean | void>;
+
+export interface ProductionRunListProps {
+  /** Runs to show, in the host's order. */
+  runs: ProductionRunView[];
+  /**
+   * Records `qty` finished units on the run; omit to hide reporting. Return
+   * `false` or throw to report a failure.
+   */
+  oncomplete?: (runId: string, qty: number) => HandlerResult;
+  /** Message shown when there are no runs. */
+  emptyMessage?: string;
+}
+
+const { runs, oncomplete, emptyMessage }: ProductionRunListProps = $props();
+
+const uid = $props.id();
+
+let drafts = $state<Record<string, string>>({});
+let errors = $state<Record<string, string>>({});
+let busy = $state<Record<string, boolean>>({});
+
+/** What is left, at the six-decimal quantity precision the service uses. */
+function remainingOf(run: ProductionRunView): number {
+  return Math.max(0, Number((run.targetQty - run.completedQty).toFixed(6)));
+}
+
+async function report(run: ProductionRunView) {
+  if (!oncomplete) return;
+  const result = validateCompletionQty(drafts[run.id] ?? '', run);
+  if (!result.ok) {
+    errors[run.id] =
+      result.reason === 'too_many'
+        ? t(M['manufacturing.production_run_list.error_too_many'], {
+            remaining: remainingOf(run),
+          })
+        : t(M['manufacturing.production_run_list.error_qty']);
+    return;
+  }
+  errors[run.id] = '';
+  busy[run.id] = true;
+  try {
+    if ((await oncomplete(run.id, result.qty)) === false) {
+      errors[run.id] = t(M['manufacturing.production_run_list.error_failed']);
+    } else {
+      drafts[run.id] = '';
+    }
+  } catch {
+    errors[run.id] = t(M['manufacturing.production_run_list.error_failed']);
+  } finally {
+    busy[run.id] = false;
+  }
+}
+</script>
+
+{#if runs.length === 0}
+  <p class="run-list-empty">
+    {emptyMessage ?? t(M['manufacturing.production_run_list.empty'])}
+  </p>
+{:else}
+  <div class="run-list-scroll">
+    <table class="run-list">
+      <caption class="run-list-caption">{t(M['manufacturing.production_run_list.caption'])}</caption>
+      <thead>
+        <tr>
+          <th scope="col">{t(M['manufacturing.production_run_list.build'])}</th>
+          <th scope="col">{t(M['manufacturing.production_run_list.progress'])}</th>
+          <th scope="col">{t(M['manufacturing.production_run_list.status'])}</th>
+          {#if oncomplete}
+            <th scope="col">{t(M['manufacturing.production_run_list.report'])}</th>
+          {/if}
+        </tr>
+      </thead>
+      <tbody>
+        {#each runs as run (run.id)}
+          {@const progressText = t(M['manufacturing.production_run_list.progress_value'], {
+            completed: run.completedQty,
+            target: run.targetQty,
+          })}
+          {@const errorId = `${uid}-${run.id}-error`}
+          <tr>
+            <th scope="row">{run.label}</th>
+            <td class="run-list-progress">
+              <ProgressBar
+                value={run.completedQty}
+                max={run.targetQty > 0 ? run.targetQty : 1}
+                status="healthy"
+                size="sm"
+                showLabel
+                label={progressText}
+              />
+            </td>
+            <td>
+              <StatusBadge
+                status={run.status}
+                tone={productionRunStatusTone(run.status)}
+                label={t(productionRunStatusLabelKey(run.status))}
+                size="sm"
+              />
+            </td>
+            {#if oncomplete}
+              <td>
+                {#if isProductionRunOpen(run.status)}
+                  <Form class="run-list-report" onsubmit={() => report(run)}>
+                    <Input
+                      type="number"
+                      inputmode="decimal"
+                      step="any"
+                      min="0"
+                      value={drafts[run.id] ?? ''}
+                      oninput={(event) => {
+                        drafts[run.id] = (event.currentTarget as HTMLInputElement).value;
+                      }}
+                      disabled={busy[run.id]}
+                      aria-label={t(M['manufacturing.production_run_list.qty_aria'], { label: run.label })}
+                      aria-invalid={errors[run.id] ? 'true' : undefined}
+                      aria-describedby={errors[run.id] ? errorId : undefined}
+                    />
+                    <Button
+                      type="submit"
+                      size="sm"
+                      disabled={busy[run.id]}
+                      aria-label={t(M['manufacturing.production_run_list.submit_aria'], { label: run.label })}
+                    >
+                      {t(M['manufacturing.production_run_list.submit'])}
+                    </Button>
+                  </Form>
+                  {#if errors[run.id]}
+                    <p class="run-list-error" id={errorId} role="alert">{errors[run.id]}</p>
+                  {/if}
+                {/if}
+              </td>
+            {/if}
+          </tr>
+        {/each}
+      </tbody>
+    </table>
+  </div>
+{/if}
+
+<style>
+  .run-list-scroll {
+    overflow-x: auto;
+  }
+
+  .run-list {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  .run-list-caption {
+    text-align: left;
+    font-weight: var(--smrt-typography-title-medium-weight, 500);
+    padding-bottom: 0.5rem;
+  }
+
+  .run-list th,
+  .run-list td {
+    padding: 0.5rem;
+    text-align: left;
+    vertical-align: top;
+    border-bottom: 1px solid var(--smrt-color-outline-variant, transparent);
+  }
+
+  .run-list-progress {
+    min-width: 10rem;
+  }
+
+  .run-list :global(.run-list-report) {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+  }
+
+  .run-list :global(.run-list-report input) {
+    width: 6rem;
+  }
+
+  .run-list-error {
+    margin: 0.25rem 0 0;
+    color: var(--smrt-color-error, inherit);
+  }
+
+  .run-list-empty {
+    margin: 0;
+    color: var(--smrt-color-on-surface-variant, inherit);
+  }
+</style>

package/dist/svelte/components/ProductionRunList.svelte.d.ts

@@ -0,0 +1,18 @@
+import { type ProductionRunView } from '../types.js';
+/** What a host handler may return: `false` (or a throw) keeps the field as typed. */
+type HandlerResult = boolean | void | Promise<boolean | void>;
+export interface ProductionRunListProps {
+    /** Runs to show, in the host's order. */
+    runs: ProductionRunView[];
+    /**
+     * Records `qty` finished units on the run; omit to hide reporting. Return
+     * `false` or throw to report a failure.
+     */
+    oncomplete?: (runId: string, qty: number) => HandlerResult;
+    /** Message shown when there are no runs. */
+    emptyMessage?: string;
+}
+declare const ProductionRunList: import("svelte").Component<ProductionRunListProps, {}, "">;
+type ProductionRunList = ReturnType<typeof ProductionRunList>;
+export default ProductionRunList;
+//# sourceMappingURL=ProductionRunList.svelte.d.ts.map

package/dist/svelte/components/ProductionRunList.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionRunList.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/ProductionRunList.svelte.ts"],"names":[],"mappings":"AAeA,OAAO,EAEL,KAAK,iBAAiB,EAIvB,MAAM,aAAa,CAAC;AAGrB,qFAAqF;AACrF,KAAK,aAAa,GAAG,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE9D,MAAM,WAAW,sBAAsB;IACrC,yCAAyC;IACzC,IAAI,EAAE,iBAAiB,EAAE,CAAC;IAC1B;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,aAAa,CAAC;IAC3D,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAoHD,QAAA,MAAM,iBAAiB,4DAAwC,CAAC;AAChE,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,eAAe,iBAAiB,CAAC"}

package/dist/svelte/components/RequirementsTree.svelte

@@ -0,0 +1,125 @@
+<script lang="ts">
+/**
+ * RequirementsTree — a read-only view of an exploded bill: each line with its
+ * level, component, kind and required quantity, nested under the
+ * sub-assembly whose bill it belongs to, and the totals. From a plan
+ * (`BomService.planRequirements`) each line also shows the available stock
+ * and how much is short; a short sub-assembly that was opened lists what
+ * building the shortfall takes.
+ *
+ * The host adapts the result with `toRequirementTree` and
+ * `toRequirementTotals`. This shows facts only: whether to build or buy is
+ * the host's decision.
+ */
+
+import { Badge } from '@happyvertical/smrt-ui';
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { M } from '../i18n.js';
+import type { RequirementLineView, RequirementTotalView } from '../types.js';
+import RequirementsTreeLevel from './RequirementsTreeLevel.svelte';
+
+const { t } = useI18n();
+
+export interface RequirementsTreeProps {
+  /** The top bill's lines, each with the lines walked below it. */
+  lines: RequirementLineView[];
+  /** Totals per component; omit to hide the table. */
+  totals?: RequirementTotalView[];
+  /** Accessible name for the tree; defaults to "Requirements". */
+  label?: string;
+}
+
+const { lines, totals, label }: RequirementsTreeProps = $props();
+
+const showShort = $derived(
+  (totals ?? []).some((total) => total.short !== null),
+);
+
+function quantity(value: number): string {
+  return String(Number(value.toFixed(6)));
+}
+
+function componentText(name: string, skuCode: string): string {
+  const shown = name || t(M['manufacturing.requirements.unnamed']);
+  return skuCode && skuCode !== name ? `${shown} (${skuCode})` : shown;
+}
+</script>
+
+{#if lines.length === 0}
+  <p class="requirements-empty">{t(M['manufacturing.requirements.empty'])}</p>
+{:else}
+  <RequirementsTreeLevel
+    {lines}
+    label={label ?? t(M['manufacturing.requirements.label'])}
+  />
+{/if}
+
+{#if totals && totals.length > 0}
+  <div class="requirements-scroll">
+    <table class="requirements-totals">
+      <caption>{t(M['manufacturing.requirements.totals_caption'])}</caption>
+      <thead>
+        <tr>
+          <th scope="col">{t(M['manufacturing.requirements.component'])}</th>
+          <th scope="col">{t(M['manufacturing.requirements.total_required'])}</th>
+          <th scope="col">{t(M['manufacturing.requirements.uom'])}</th>
+          {#if showShort}
+            <th scope="col">{t(M['manufacturing.requirements.total_short'])}</th>
+          {/if}
+        </tr>
+      </thead>
+      <tbody>
+        {#each totals as total (total.componentSkuId)}
+          <tr>
+            <th scope="row">{componentText(total.name, total.skuCode)}</th>
+            <td class="requirements-number">{quantity(total.required)}</td>
+            <td>{total.uom}</td>
+            {#if showShort}
+              <td class="requirements-number">
+                {#if total.short !== null && total.short > 0}
+                  <Badge size="sm" variant="error">{quantity(total.short)}</Badge>
+                {:else}
+                  {quantity(total.short ?? 0)}
+                {/if}
+              </td>
+            {/if}
+          </tr>
+        {/each}
+      </tbody>
+    </table>
+  </div>
+{/if}
+
+<style>
+  .requirements-empty {
+    margin: 0;
+    color: var(--smrt-color-on-surface-variant, inherit);
+  }
+
+  .requirements-scroll {
+    overflow-x: auto;
+    margin-top: 1rem;
+  }
+
+  .requirements-totals {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  .requirements-totals caption {
+    text-align: left;
+    font-weight: var(--smrt-typography-title-medium-weight, 500);
+    padding-bottom: 0.5rem;
+  }
+
+  .requirements-totals th,
+  .requirements-totals td {
+    padding: 0.375rem 0.5rem;
+    text-align: left;
+    border-bottom: 1px solid var(--smrt-color-outline-variant, transparent);
+  }
+
+  .requirements-number {
+    font-variant-numeric: tabular-nums;
+  }
+</style>

package/dist/svelte/components/RequirementsTree.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { RequirementLineView, RequirementTotalView } from '../types.js';
+export interface RequirementsTreeProps {
+    /** The top bill's lines, each with the lines walked below it. */
+    lines: RequirementLineView[];
+    /** Totals per component; omit to hide the table. */
+    totals?: RequirementTotalView[];
+    /** Accessible name for the tree; defaults to "Requirements". */
+    label?: string;
+}
+declare const RequirementsTree: import("svelte").Component<RequirementsTreeProps, {}, "">;
+type RequirementsTree = ReturnType<typeof RequirementsTree>;
+export default RequirementsTree;
+//# sourceMappingURL=RequirementsTree.svelte.d.ts.map

package/dist/svelte/components/RequirementsTree.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequirementsTree.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/RequirementsTree.svelte.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI7E,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,oDAAoD;IACpD,MAAM,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAChC,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA2ED,QAAA,MAAM,gBAAgB,2DAAwC,CAAC;AAC/D,KAAK,gBAAgB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC5D,eAAe,gBAAgB,CAAC"}

package/dist/svelte/components/RequirementsTreeLevel.svelte

@@ -0,0 +1,120 @@
+<script lang="ts">
+/**
+ * One level of `RequirementsTree`: a list of lines, each followed by the
+ * lines of its sub-assembly's bill when the walk opened it. Internal to
+ * `RequirementsTree`.
+ */
+
+import { Badge } from '@happyvertical/smrt-ui';
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { M } from '../i18n.js';
+import { componentKindLabelKey, type RequirementLineView } from '../types.js';
+import RequirementsTreeLevel from './RequirementsTreeLevel.svelte';
+
+const { t } = useI18n();
+
+export interface RequirementsTreeLevelProps {
+  /** The lines of this level. */
+  lines: RequirementLineView[];
+  /** Accessible name for the list. */
+  label: string;
+}
+
+const { lines, label }: RequirementsTreeLevelProps = $props();
+
+function quantity(value: number): string {
+  return String(Number(value.toFixed(6)));
+}
+
+function componentText(line: RequirementLineView): string {
+  const shown = line.name || t(M['manufacturing.requirements.unnamed']);
+  return line.skuCode && line.skuCode !== line.name
+    ? `${shown} (${line.skuCode})`
+    : shown;
+}
+</script>
+
+<ul class="requirements-tree" aria-label={label}>
+  {#each lines as line (line.key)}
+    <li class="requirements-line" data-level={line.level}>
+      <div class="requirements-row">
+        <span class="requirements-component">{componentText(line)}</span>
+        <Badge size="sm" variant={line.kind === 'missing' ? 'error' : 'default'}>
+          {t(componentKindLabelKey(line.kind))}
+        </Badge>
+        <span class="requirements-qty">
+          {t(M['manufacturing.requirements.required'], {
+            qty: quantity(line.required),
+            uom: line.uom,
+          })}
+        </span>
+        {#if line.available !== null}
+          <span class="requirements-qty">
+            {t(M['manufacturing.requirements.available'], { qty: quantity(line.available) })}
+          </span>
+        {/if}
+        {#if line.short !== null}
+          {#if line.short > 0}
+            <Badge size="sm" variant="error">
+              {t(M['manufacturing.requirements.short'], { qty: quantity(line.short) })}
+            </Badge>
+          {:else}
+            <span class="requirements-note">{t(M['manufacturing.requirements.covered'])}</span>
+          {/if}
+        {/if}
+        {#if line.kind === 'assembly' && !line.buildable}
+          <span class="requirements-note">{t(M['manufacturing.requirements.no_bill'])}</span>
+        {:else if line.buildable && line.children.length === 0 && (line.short ?? 0) > 0}
+          <span class="requirements-note">{t(M['manufacturing.requirements.buildable'])}</span>
+        {/if}
+      </div>
+      {#if line.children.length > 0}
+        <div class="requirements-children">
+          <RequirementsTreeLevel
+            lines={line.children}
+            label={t(M['manufacturing.requirements.sub_label'], {
+              component: line.name || t(M['manufacturing.requirements.unnamed']),
+            })}
+          />
+        </div>
+      {/if}
+    </li>
+  {/each}
+</ul>
+
+<style>
+  .requirements-tree {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .requirements-line {
+    padding: 0.25rem 0;
+  }
+
+  .requirements-row {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .requirements-component {
+    font-weight: var(--smrt-typography-title-small-weight, 500);
+  }
+
+  .requirements-qty {
+    font-variant-numeric: tabular-nums;
+  }
+
+  .requirements-note {
+    color: var(--smrt-color-on-surface-variant, inherit);
+  }
+
+  .requirements-children {
+    margin-left: 1rem;
+    padding-left: 0.75rem;
+    border-left: 2px solid var(--smrt-color-outline-variant, transparent);
+  }
+</style>

package/dist/svelte/components/RequirementsTreeLevel.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type RequirementLineView } from '../types.js';
+import RequirementsTreeLevel from './RequirementsTreeLevel.svelte';
+export interface RequirementsTreeLevelProps {
+    /** The lines of this level. */
+    lines: RequirementLineView[];
+    /** Accessible name for the list. */
+    label: string;
+}
+declare const RequirementsTreeLevel: import("svelte").Component<RequirementsTreeLevelProps, {}, "">;
+type RequirementsTreeLevel = ReturnType<typeof RequirementsTreeLevel>;
+export default RequirementsTreeLevel;
+//# sourceMappingURL=RequirementsTreeLevel.svelte.d.ts.map

package/dist/svelte/components/RequirementsTreeLevel.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequirementsTreeLevel.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/RequirementsTreeLevel.svelte.ts"],"names":[],"mappings":"AAWA,OAAO,EAAyB,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,qBAAqB,MAAM,gCAAgC,CAAC;AAGnE,MAAM,WAAW,0BAA0B;IACzC,+BAA+B;IAC/B,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf;AA4ED,QAAA,MAAM,qBAAqB,gEAAwC,CAAC;AACpE,KAAK,qBAAqB,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACtE,eAAe,qBAAqB,CAAC"}

package/dist/svelte/i18n.d.ts

@@ -83,5 +83,37 @@ export declare const M: {
     readonly 'manufacturing.bom_editor.error_qty': "manufacturing.bom_editor.error_qty";
     readonly 'manufacturing.bom_editor.error_uom': "manufacturing.bom_editor.error_uom";
     readonly 'manufacturing.bom_editor.error_waste': "manufacturing.bom_editor.error_waste";
+    readonly 'manufacturing.production_run_list.caption': "manufacturing.production_run_list.caption";
+    readonly 'manufacturing.production_run_list.empty': "manufacturing.production_run_list.empty";
+    readonly 'manufacturing.production_run_list.build': "manufacturing.production_run_list.build";
+    readonly 'manufacturing.production_run_list.progress': "manufacturing.production_run_list.progress";
+    readonly 'manufacturing.production_run_list.status': "manufacturing.production_run_list.status";
+    readonly 'manufacturing.production_run_list.report': "manufacturing.production_run_list.report";
+    readonly 'manufacturing.production_run_list.progress_value': "manufacturing.production_run_list.progress_value";
+    readonly 'manufacturing.production_run_list.qty_aria': "manufacturing.production_run_list.qty_aria";
+    readonly 'manufacturing.production_run_list.submit': "manufacturing.production_run_list.submit";
+    readonly 'manufacturing.production_run_list.submit_aria': "manufacturing.production_run_list.submit_aria";
+    readonly 'manufacturing.production_run_list.error_qty': "manufacturing.production_run_list.error_qty";
+    readonly 'manufacturing.production_run_list.error_too_many': "manufacturing.production_run_list.error_too_many";
+    readonly 'manufacturing.production_run_list.error_failed': "manufacturing.production_run_list.error_failed";
+    readonly 'manufacturing.production_run_status.planned': "manufacturing.production_run_status.planned";
+    readonly 'manufacturing.production_run_status.in_progress': "manufacturing.production_run_status.in_progress";
+    readonly 'manufacturing.production_run_status.done': "manufacturing.production_run_status.done";
+    readonly 'manufacturing.production_run_status.cancelled': "manufacturing.production_run_status.cancelled";
+    readonly 'manufacturing.requirements.label': "manufacturing.requirements.label";
+    readonly 'manufacturing.requirements.sub_label': "manufacturing.requirements.sub_label";
+    readonly 'manufacturing.requirements.required': "manufacturing.requirements.required";
+    readonly 'manufacturing.requirements.available': "manufacturing.requirements.available";
+    readonly 'manufacturing.requirements.short': "manufacturing.requirements.short";
+    readonly 'manufacturing.requirements.covered': "manufacturing.requirements.covered";
+    readonly 'manufacturing.requirements.buildable': "manufacturing.requirements.buildable";
+    readonly 'manufacturing.requirements.no_bill': "manufacturing.requirements.no_bill";
+    readonly 'manufacturing.requirements.totals_caption': "manufacturing.requirements.totals_caption";
+    readonly 'manufacturing.requirements.component': "manufacturing.requirements.component";
+    readonly 'manufacturing.requirements.total_required': "manufacturing.requirements.total_required";
+    readonly 'manufacturing.requirements.uom': "manufacturing.requirements.uom";
+    readonly 'manufacturing.requirements.total_short': "manufacturing.requirements.total_short";
+    readonly 'manufacturing.requirements.empty': "manufacturing.requirements.empty";
+    readonly 'manufacturing.requirements.unnamed': "manufacturing.requirements.unnamed";
 };
 //# sourceMappingURL=i18n.d.ts.map

package/dist/svelte/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/svelte/i18n.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFZ,CAAC"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/svelte/i18n.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8HZ,CAAC"}

package/dist/svelte/i18n.js

@@ -84,4 +84,36 @@ export const M = defineMessages({
     'manufacturing.bom_editor.error_qty': 'Enter a quantity greater than zero.',
     'manufacturing.bom_editor.error_uom': 'Enter a unit.',
     'manufacturing.bom_editor.error_waste': 'Enter a waste percent of zero or more.',
+    'manufacturing.production_run_list.caption': 'Production runs',
+    'manufacturing.production_run_list.empty': 'No production runs',
+    'manufacturing.production_run_list.build': 'Build',
+    'manufacturing.production_run_list.progress': 'Progress',
+    'manufacturing.production_run_list.status': 'Status',
+    'manufacturing.production_run_list.report': 'Report completion',
+    'manufacturing.production_run_list.progress_value': '{completed} of {target} done',
+    'manufacturing.production_run_list.qty_aria': 'Quantity completed for {label}',
+    'manufacturing.production_run_list.submit': 'Report',
+    'manufacturing.production_run_list.submit_aria': 'Report a completion for {label}',
+    'manufacturing.production_run_list.error_qty': 'Enter a quantity greater than zero.',
+    'manufacturing.production_run_list.error_too_many': 'Only {remaining} left to build.',
+    'manufacturing.production_run_list.error_failed': 'The completion could not be recorded.',
+    'manufacturing.production_run_status.planned': 'Planned',
+    'manufacturing.production_run_status.in_progress': 'In progress',
+    'manufacturing.production_run_status.done': 'Done',
+    'manufacturing.production_run_status.cancelled': 'Cancelled',
+    'manufacturing.requirements.label': 'Requirements',
+    'manufacturing.requirements.sub_label': 'Building {component} takes',
+    'manufacturing.requirements.required': 'Required: {qty} {uom}',
+    'manufacturing.requirements.available': 'Available: {qty}',
+    'manufacturing.requirements.short': 'Short: {qty}',
+    'manufacturing.requirements.covered': 'Covered',
+    'manufacturing.requirements.buildable': 'Can be built from its bill',
+    'manufacturing.requirements.no_bill': 'No active bill',
+    'manufacturing.requirements.totals_caption': 'Totals',
+    'manufacturing.requirements.component': 'Component',
+    'manufacturing.requirements.total_required': 'Required',
+    'manufacturing.requirements.uom': 'Unit',
+    'manufacturing.requirements.total_short': 'Short',
+    'manufacturing.requirements.empty': 'Nothing is required',
+    'manufacturing.requirements.unnamed': 'Unknown component',
 });

package/dist/svelte/index.d.ts

@@ -4,8 +4,9 @@
  * Props-driven Svelte 5 surfaces: the managed list of operations (a list with
  * retire and reinstate, and a form), and assemblies (a list, a policy-driven
  * form, and a bill-of-materials editor whose sub-assemblies expand to their own
- * bills). Hosts load data through the package services and collections and
- * pass plain view objects.
+ * bills), production runs with their progress and completion reporting, and
+ * the read-only exploded requirements of a bill. Hosts load data through the
+ * package services and collections and pass plain view objects.
  * Auto-registers components with ModuleUIRegistry on import.
  *
  * @packageDocumentation
@@ -17,12 +18,16 @@ import BomEditor from './components/BomEditor.svelte';
 import BomStructureTree from './components/BomStructureTree.svelte';
 import OperationForm from './components/OperationForm.svelte';
 import OperationList from './components/OperationList.svelte';
-export { AssemblyForm, AssemblyList, BomEditor, BomStructureTree, OperationForm, OperationList, };
+import ProductionRunList from './components/ProductionRunList.svelte';
+import RequirementsTree from './components/RequirementsTree.svelte';
+export { AssemblyForm, AssemblyList, BomEditor, BomStructureTree, OperationForm, OperationList, ProductionRunList, RequirementsTree, };
 export type AssemblyFormProps = ComponentProps<typeof AssemblyForm>;
 export type AssemblyListProps = ComponentProps<typeof AssemblyList>;
 export type BomEditorProps = ComponentProps<typeof BomEditor>;
 export type BomStructureTreeProps = ComponentProps<typeof BomStructureTree>;
 export type OperationFormProps = ComponentProps<typeof OperationForm>;
 export type OperationListProps = ComponentProps<typeof OperationList>;
-export { type AssemblyView, type BomComponentOption, type BomEditorLine, type BomLineDraft, type BomLineDraftField, type BomLineInput, type BomLineValidation, type ComponentKind, componentKindLabelKey, type OperationFormDraft, type OperationFormField, type OperationFormInitial, type OperationFormValidation, type OperationFormValues, type OperationView, operationStatusBadgeKey, splitLabourMinutes, toAssemblyView, toBomEditorLine, toBomEditorLines, validateBomLineInput, validateOperationForm, } from './types.js';
+export type ProductionRunListProps = ComponentProps<typeof ProductionRunList>;
+export type RequirementsTreeProps = ComponentProps<typeof RequirementsTree>;
+export { type AssemblyView, type BomComponentOption, type BomEditorLine, type BomLineDraft, type BomLineDraftField, type BomLineInput, type BomLineValidation, type CompletionQtyValidation, type ComponentKind, componentKindLabelKey, isProductionRunOpen, type OperationFormDraft, type OperationFormField, type OperationFormInitial, type OperationFormValidation, type OperationFormValues, type OperationView, operationStatusBadgeKey, type ProductionRunStatus, type ProductionRunView, productionRunStatusLabelKey, productionRunStatusTone, type RequirementLineView, type RequirementTotalView, splitLabourMinutes, toAssemblyView, toBomEditorLine, toBomEditorLines, toProductionRunView, toRequirementTotals, toRequirementTree, validateBomLineInput, validateCompletionQty, validateOperationForm, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAE7C,OAAO,YAAY,MAAM,kCAAkC,CAAC;AAC5D,OAAO,YAAY,MAAM,kCAAkC,CAAC;AAC5D,OAAO,SAAS,MAAM,+BAA+B,CAAC;AACtD,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AACpE,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAE9D,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,aAAa,GACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,OAAO,YAAY,CAAC,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,OAAO,YAAY,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC,OAAO,SAAS,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5E,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,aAAa,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,aAAa,CAAC,CAAC;AAEtE,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAE7C,OAAO,YAAY,MAAM,kCAAkC,CAAC;AAC5D,OAAO,YAAY,MAAM,kCAAkC,CAAC;AAC5D,OAAO,SAAS,MAAM,+BAA+B,CAAC;AACtD,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AACpE,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,iBAAiB,MAAM,uCAAuC,CAAC;AACtE,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AAEpE,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,OAAO,YAAY,CAAC,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,OAAO,YAAY,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC,OAAO,SAAS,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5E,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,aAAa,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,aAAa,CAAC,CAAC;AACtE,MAAM,MAAM,sBAAsB,GAAG,cAAc,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5E,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,2BAA2B,EAC3B,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}