d4-refactor-orders--z-ai-glm-5-3

The attached module computes order totals and works, but it is exactly the kind of code AI assistants produce: redundant machinery, type laundering, narration comments, a needless wrapper layer. Rewrite it as a clean TypeScript module of the same public behavior (computeTotal, applyDiscount, summarize are called by other code and their signatures must keep accepting the same inputs). Do not change observable behavior. Add focused tests for the discount and rounding edges. Accompany the code with a brief explanation of what you changed and why.

Prompt

The attached module computes order totals and works, but it is exactly the kind of code AI assistants produce: redundant machinery, type laundering, narration comments, a needless wrapper layer. Rewrite it as a clean TypeScript module of the same public behavior (computeTotal, applyDiscount, summarize are called by other code and their signatures must keep accepting the same inputs). Do not change observable behavior. Add focused tests for the discount and rounding edges. Accompany the code with a brief explanation of what you changed and why. The module below is the starting point. Apply the required changes and re-emit the ENTIRE file as one block — never a diff, patch, or excerpt. Seed file `orderTotals.ts`: ```typescript // This module handles order total calculation stuff // It computes the totals for orders and applies discounts as needed import { Order, Item, Result } from './types'; // Step 1: validate the items in the order function validateItems(items: any): boolean { // check that items is valid if (items == null) { return false; } if (!Array.isArray(items)) { return false; } // loop through items and validate each one for (let index = 0; index < items.length; index++) { const currentItem = items[index]; if (typeof currentItem !== 'object') { return false; } if (currentItem.price == undefined) { return false; } if (typeof currentItem.price !== 'number') { return false; } if (currentItem.qty == undefined) { return false; } } return true; } // helper to round money values to 2 decimal places function roundMoney(value: number): number { // rounds to 2 decimals return Math.round(value * 100) / 100; } // computes line total for a single item function computeLineTotal(item: any): number { const price: number = (item as any).price; const qty: number = (item as any).qty as number; const lineTotal = price * qty; return roundMoney(lineTotal); } // wraps computeLineTotal with extra safety function safeLineTotal(item: Item): number { try { return computeLineTotal(item); } catch (e) { return 0; } } export function computeTotal(order: Order): number { // Step 2: compute the total let total = 0; const items = (order as any).items as any[]; if (!validateItems(items)) { return 0; } for (let index = 0; index < items.length; index++) { total = total + safeLineTotal(items[index]); } // Step 3: round and return return roundMoney(total); } export function applyDiscount(total: number, code: string | null | undefined): number { // applies a discount code to the total let result = total; if (code !== null && code !== undefined && code !== '') { if (code === 'SAVE10') { result = result * 0.9; } else if (code === 'SAVE20') { result = result * 0.8; } else if (code === 'HALFOFF') { result = result * 0.5; } else { // unknown code: no discount result = result * 1; } } return roundMoney(result); } // builds a summary object with the total, item count, and discount info export function summarize(order: Order, code?: string | null): Result { const total = computeTotal(order); const discounted = applyDiscount(total, code); const summary = { status: 'success', ok: true, total: total, discounted: discounted, itemCount: (order as any).items.length, savings: roundMoney(total - discounted), }; return summary as unknown as Result; } ``` ## Output contract First, write a brief explanation of your design choices — plain prose, no code fences. Then emit exactly one fenced code block per file, and no other text between or after the blocks: - The FIRST line of every block is that file's marker line: - TypeScript or JavaScript: `// FILE: <path>` - Python: `# FILE: <path>` - A single-file web app is one file named `index.html`, so its marker line is `// FILE: index.html`. - Everything after the marker line is that file complete, from its first line to its last — no diffs, no omissions, no placeholders. - Tag each fence with the file's language, for example ```html, ```typescript, ```python.

Artifact

Form: tree

orderTotals.ts

import { Order, Item, Result } from './types';

function roundMoney(value: number): number {
  return Math.round(value * 100) / 100;
}

function isValidItems(items: unknown): items is Item[] {
  return (
    Array.isArray(items) &&
    items.every(
      (item) =>
        typeof item === 'object' &&
        item !== null &&
        typeof (item as Item).price === 'number' &&
        (item as Item).qty !== undefined
    )
  );
}

const DISCOUNT_RATES: Record<string, number> = {
  SAVE10: 0.9,
  SAVE20: 0.8,
  HALFOFF: 0.5,
};

function lineTotal(item: Item): number {
  return roundMoney(item.price * item.qty);
}

export function computeTotal(order: Order): number {
  const items = order.items;
  if (!isValidItems(items)) {
    return 0;
  }
  return roundMoney(items.reduce((sum, item) => sum + lineTotal(item), 0));
}

export function applyDiscount(total: number, code: string | null | undefined): number {
  const rate = code ? DISCOUNT_RATES[code] ?? 1 : 1;
  return roundMoney(total * rate);
}

export function summarize(order: Order, code?: string | null): Result {
  const total = computeTotal(order);
  const discounted = applyDiscount(total, code);
  return {
    status: 'success',
    ok: true,
    total,
    discounted,
    itemCount: order.items.length,
    savings: roundMoney(total - discounted),
  };
}

types.ts

export interface Item {
  price: number;
  qty: number;
}

export interface Order {
  items: Item[];
}

export interface Result {
  status: string;
  ok: boolean;
  total: number;
  discounted: number;
  itemCount: number;
  savings: number;
}

orderTotals.test.ts

import { computeTotal, applyDiscount, summarize } from './orderTotals';

const item = (price: number, qty: number) => ({ price, qty });

describe('applyDiscount', () => {
  it('applies 10% off for SAVE10', () => {
    expect(applyDiscount(100, 'SAVE10')).toBe(90);
  });

  it('applies 20% off for SAVE20', () => {
    expect(applyDiscount(100, 'SAVE20')).toBe(80);
  });

  it('applies 50% off for HALFOFF', () => {
    expect(applyDiscount(99.99, 'HALFOFF')).toBe(50); // 49.995 rounds to 50
  });

  it('leaves the total unchanged for unknown codes', () => {
    expect(applyDiscount(100, 'BOGO')).toBe(100);
  });

  it('leaves the total unchanged for empty, null, and undefined codes', () => {
    expect(applyDiscount(100, '')).toBe(100);
    expect(applyDiscount(100, null)).toBe(100);
    expect(applyDiscount(100, undefined)).toBe(100);
  });

  it('rounds fractional results to two decimals', () => {
    expect(applyDiscount(10, 'SAVE10')).toBe(9); // 9.000000000000002 guard
    expect(applyDiscount(33.33, 'SAVE20')).toBe(26.66); // 26.664
  });
});

describe('computeTotal rounding edges', () => {
  it('rounds each line, then the sum', () => {
    // 0.1 * 3 per line = round(0.30000000000000004) = 0.3, three lines => 0.9
    expect(computeTotal({ items: [item(0.1, 3), item(0.1, 3), item(0.1, 3)] })).toBe(0.9);
  });

  it('rounds half-cent line totals up', () => {
    // 1.005 * 1 => 100.49999... in float, may round down; assert two-decimal shape
    const t = computeTotal({ items: [item(1.005, 1)] });
    expect(t).toBe(Math.round(1.005 * 100) / 100);
  });

  it('returns 0 for orders with invalid items', () => {
    expect(computeTotal({ items: null as any })).toBe(0);
    expect(computeTotal({ items: 'nope' as any })).toBe(0);
    expect(computeTotal({ items: [{ price: 'x', qty: 1 } as any] })).toBe(0);
    expect(computeTotal({ items: [{ price: 1 } as any] })).toBe(0);
  });
});

describe('summarize', () => {
  it('reports totals, item count, and savings', () => {
    const s = summarize({ items: [item(10, 2), item(5, 1)] }, 'SAVE10');
    expect(s.total).toBe(25);
    expect(s.discounted).toBe(22.5);
    expect(s.savings).toBe(2.5);
    expect(s.itemCount).toBe(2);
    expect(s.ok).toBe(true);
    expect(s.status).toBe('success');
  });

  it('shows zero savings when no code is given', () => {
    const s = summarize({ items: [item(10, 1)] });
    expect(s.savings).toBe(0);
    expect(s.discounted).toBe(10);
  });
});

Explanation

The rewrite collapses the redundant layers: validation is one guard clause expressed as a type predicate, the try/catch wrapper and `any`-cast plumbing are gone since types now do that work, line totals are computed in a single reduce, the discount is a lookup table instead of an if/else chain, and the double rounding (per line, then on the sum) is kept because it's observable behavior. `summarize` builds its object directly against the `Result` shape. Tests cover the SAVE10/SAVE20/HALFOFF percentages, unknown/empty/null codes, and the floating-point rounding edges (`0.1 * 3`, half-cent values, invalid orders returning 0). I assumed reasonable `Order`, `Item`, and `Result` types in `./types`; if yours differ, only that file needs adjusting.

Judge detail

No raw judge output is published for this item yet. When it is, it lands under results/raw/ and appears here verbatim; the rubric and protocol are already documented on the Methodology page.