@happyvertical/smrt-manufacturing 0.53.5 → 0.54.0

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

@@ -31,6 +31,29 @@ export declare const M: {
     readonly 'manufacturing.operation_form.cancel': "manufacturing.operation_form.cancel";
     readonly 'manufacturing.operation_form.error_code': "manufacturing.operation_form.error_code";
     readonly 'manufacturing.operation_form.error_name': "manufacturing.operation_form.error_name";
+    readonly 'manufacturing.assembly_form.name': "manufacturing.assembly_form.name";
+    readonly 'manufacturing.assembly_form.description': "manufacturing.assembly_form.description";
+    readonly 'manufacturing.assembly_form.category': "manufacturing.assembly_form.category";
+    readonly 'manufacturing.assembly_form.part_reference': "manufacturing.assembly_form.part_reference";
+    readonly 'manufacturing.assembly_form.part_reference_help': "manufacturing.assembly_form.part_reference_help";
+    readonly 'manufacturing.assembly_form.price': "manufacturing.assembly_form.price";
+    readonly 'manufacturing.assembly_form.price_help': "manufacturing.assembly_form.price_help";
+    readonly 'manufacturing.assembly_form.labour': "manufacturing.assembly_form.labour";
+    readonly 'manufacturing.assembly_form.labour_help': "manufacturing.assembly_form.labour_help";
+    readonly 'manufacturing.assembly_form.operation': "manufacturing.assembly_form.operation";
+    readonly 'manufacturing.assembly_form.operation_help': "manufacturing.assembly_form.operation_help";
+    readonly 'manufacturing.assembly_form.operation_none': "manufacturing.assembly_form.operation_none";
+    readonly 'manufacturing.assembly_form.operation_retired': "manufacturing.assembly_form.operation_retired";
+    readonly 'manufacturing.assembly_form.operation_unknown': "manufacturing.assembly_form.operation_unknown";
+    readonly 'manufacturing.assembly_form.tags': "manufacturing.assembly_form.tags";
+    readonly 'manufacturing.assembly_form.tags_help': "manufacturing.assembly_form.tags_help";
+    readonly 'manufacturing.assembly_form.submit_add': "manufacturing.assembly_form.submit_add";
+    readonly 'manufacturing.assembly_form.submit_edit': "manufacturing.assembly_form.submit_edit";
+    readonly 'manufacturing.assembly_form.saving': "manufacturing.assembly_form.saving";
+    readonly 'manufacturing.assembly_form.cancel': "manufacturing.assembly_form.cancel";
+    readonly 'manufacturing.assembly_form.error_name': "manufacturing.assembly_form.error_name";
+    readonly 'manufacturing.assembly_form.error_price': "manufacturing.assembly_form.error_price";
+    readonly 'manufacturing.assembly_form.error_labour': "manufacturing.assembly_form.error_labour";
     readonly 'manufacturing.assembly_list.caption': "manufacturing.assembly_list.caption";
     readonly 'manufacturing.assembly_list.empty': "manufacturing.assembly_list.empty";
     readonly 'manufacturing.assembly_list.name': "manufacturing.assembly_list.name";
@@ -83,5 +106,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4JZ,CAAC"}

package/dist/svelte/i18n.js

@@ -32,6 +32,29 @@ export const M = defineMessages({
     'manufacturing.operation_form.cancel': 'Cancel',
     'manufacturing.operation_form.error_code': 'Enter a code.',
     'manufacturing.operation_form.error_name': 'Enter a name.',
+    'manufacturing.assembly_form.name': 'Name',
+    'manufacturing.assembly_form.description': 'Description',
+    'manufacturing.assembly_form.category': 'Category',
+    'manufacturing.assembly_form.part_reference': 'Part reference',
+    'manufacturing.assembly_form.part_reference_help': 'Optional. Your own drawing or part number, alongside the SKU code.',
+    'manufacturing.assembly_form.price': 'Price',
+    'manufacturing.assembly_form.price_help': 'Amount in {currency}.',
+    'manufacturing.assembly_form.labour': 'Estimated labour (minutes)',
+    'manufacturing.assembly_form.labour_help': 'Whole minutes to build one unit. 0 means not estimated.',
+    'manufacturing.assembly_form.operation': 'Default operation',
+    'manufacturing.assembly_form.operation_help': 'Optional. The operation work on this assembly is booked to by default.',
+    'manufacturing.assembly_form.operation_none': 'None',
+    'manufacturing.assembly_form.operation_retired': '{label} (retired)',
+    'manufacturing.assembly_form.operation_unknown': 'Unknown operation ({id})',
+    'manufacturing.assembly_form.tags': 'Tags',
+    'manufacturing.assembly_form.tags_help': 'Optional. Separate tags with commas.',
+    'manufacturing.assembly_form.submit_add': 'Add assembly',
+    'manufacturing.assembly_form.submit_edit': 'Save changes',
+    'manufacturing.assembly_form.saving': 'Saving...',
+    'manufacturing.assembly_form.cancel': 'Cancel',
+    'manufacturing.assembly_form.error_name': 'Enter a name.',
+    'manufacturing.assembly_form.error_price': 'Enter a price of zero or more, with no more decimals than the currency has.',
+    'manufacturing.assembly_form.error_labour': 'Enter a whole number of minutes, zero or more.',
     'manufacturing.assembly_list.caption': 'Assemblies',
     'manufacturing.assembly_list.empty': 'No assemblies',
     'manufacturing.assembly_list.name': 'Name',
@@ -84,4 +107,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',
 });