Amaliy loyiha

{
  "name": "dokon",
  "type": "module",
  "private": true
}

{
  "compilerOptions": {
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitReturns": true,
    "isolatedModules": true,
    "verbatimModuleSyntax": true,
    "skipLibCheck": true,
    "outDir": "dist",
    "rootDir": "src"
  },
  "include": ["src"]
}

echo "sozlama tayyor"

export type Mahsulot = {
  readonly id: number;
  nomi: string;
  narx: number;
  soni: number;
};

export type YangiMahsulot = Omit<Mahsulot, "id">;

export type Tolov =
  | { usul: "naqd"; berilgan: number }
  | { usul: "karta"; raqam: string };

export type Natija<T> =
  | { ok: true; qiymat: T }
  | { ok: false; xato: string };

export function yaxshi<T>(qiymat: T): Natija<T> {
  return { ok: true, qiymat };
}

export function yomon<T>(xato: string): Natija<T> {
  return { ok: false, xato };
}

tsc --noEmit && echo "tsc: xato yo_q"

import { yaxshi, yomon } from "./turlar.js";
import type { Natija, YangiMahsulot } from "./turlar.js";

function obyektmi(x: unknown): x is Record<string, unknown> {
  return typeof x === "object" && x !== null && !Array.isArray(x);
}

export function tekshir(x: unknown): Natija<YangiMahsulot> {
  if (!obyektmi(x)) return yomon("obyekt kutilgan");

  const { nomi, narx, soni } = x;

  if (typeof nomi !== "string" || nomi.trim() === "") {
    return yomon("nomi bosh bolmasligi kerak");
  }
  if (typeof narx !== "number" || narx <= 0) {
    return yomon("narx musbat son bolishi kerak");
  }
  if (typeof soni !== "number" || !Number.isInteger(soni) || soni < 0) {
    return yomon("soni manfiy bolmagan butun son bolishi kerak");
  }

  return yaxshi({ nomi, narx, soni });
}

tsc --noEmit && echo "tsc: xato yo_q"

import { test } from "node:test";
import assert from "node:assert/strict";
import { tekshir } from "./tekshir.js";

const holatlar: Array<[unknown, boolean]> = [
  [{ nomi: "Olma", narx: 12000, soni: 10 }, true],
  [{ nomi: "", narx: 12000, soni: 10 }, false],
  [{ nomi: "Olma", narx: -1, soni: 10 }, false],
  [{ nomi: "Olma", narx: 12000, soni: 1.5 }, false],
  ["mahsulot emas", false],
  [null, false],
];

for (const [kirish, kutilgan] of holatlar) {
  test(`tekshir: ${JSON.stringify(kirish)}`, () => {
    assert.equal(tekshir(kirish).ok, kutilgan);
  });
}

node --import tsx --test src/tekshir.test.ts 2>&1 \
  | grep -E '^(ok|not ok|# (tests|pass|fail))'

import type { Mahsulot, YangiMahsulot } from "./turlar.js";

export type Ombor = {
  qoshish: (m: YangiMahsulot) => Promise<Mahsulot>;
  topish: (id: number) => Promise<Mahsulot | null>;
  hammasi: () => Promise<readonly Mahsulot[]>;
  yangilash: (
    id: number,
    ozgarish: Partial<YangiMahsulot>,
  ) => Promise<Mahsulot | null>;
};

export function xotiraOmbori(): Ombor {
  const yozuvlar = new Map<number, Mahsulot>();
  let keyingiId = 1;

  return {
    qoshish: async (m) => {
      const yangi: Mahsulot = { id: keyingiId, ...m };
      keyingiId += 1;
      yozuvlar.set(yangi.id, yangi);
      return yangi;
    },

    topish: async (id) => yozuvlar.get(id) ?? null,

    hammasi: async () => [...yozuvlar.values()],

    yangilash: async (id, ozgarish) => {
      const bor = yozuvlar.get(id);
      if (bor === undefined) return null;
      const yangi: Mahsulot = { ...bor, ...ozgarish };
      yozuvlar.set(id, yangi);
      return yangi;
    },
  };
}

tsc --noEmit && echo "tsc: xato yo_q"

import { yaxshi, yomon } from "./turlar.js";
import type { Mahsulot, Natija, Tolov } from "./turlar.js";
import type { Ombor } from "./ombor.js";
import { tekshir } from "./tekshir.js";

export async function qoshish(
  ombor: Ombor,
  xom: unknown,
): Promise<Natija<Mahsulot>> {
  const t = tekshir(xom);
  if (!t.ok) return yomon(t.xato);
  return yaxshi(await ombor.qoshish(t.qiymat));
}

function tolovni(tolov: Tolov, jami: number): Natija<string> {
  switch (tolov.usul) {
    case "naqd":
      if (tolov.berilgan < jami) {
        return yomon(`kam berildi: ${tolov.berilgan} < ${jami}`);
      }
      return yaxshi(`naqd, qaytim ${tolov.berilgan - jami}`);
    case "karta":
      return yaxshi(`karta ${tolov.raqam}`);
    default: {
      const qolgan: never = tolov;
      return qolgan;
    }
  }
}

export async function sotish(
  ombor: Ombor,
  id: number,
  soni: number,
  tolov: Tolov,
): Promise<Natija<string>> {
  const m = await ombor.topish(id);
  if (m === null) return yomon(`mahsulot topilmadi: ${id}`);
  if (m.soni < soni) return yomon(`omborda yetarli emas: ${m.soni}`);

  const jami = m.narx * soni;
  const t = tolovni(tolov, jami);
  if (!t.ok) return t;

  await ombor.yangilash(id, { soni: m.soni - soni });
  return yaxshi(`${m.nomi} x${soni} = ${jami}, ${t.qiymat}`);
}

tsc --noEmit && echo "tsc: xato yo_q"

import { describe, it } from "node:test";
import assert from "node:assert/strict";
import { xotiraOmbori } from "./ombor.js";
import { qoshish, sotish } from "./xizmat.js";
import type { Tolov } from "./turlar.js";

const naqd: Tolov = { usul: "naqd", berilgan: 40000 };
const karta: Tolov = { usul: "karta", raqam: "8600" };

describe("sotish", () => {
  it("naqd tolovda qaytim hisoblanadi", async () => {
    const o = xotiraOmbori();
    await qoshish(o, { nomi: "Olma", narx: 12000, soni: 10 });

    const r = await sotish(o, 1, 3, naqd);
    assert.equal(r.ok, true);
    assert.equal(
      r.ok ? r.qiymat : "",
      "Olma x3 = 36000, naqd, qaytim 4000",
    );
  });

  it("sotuvdan keyin soni kamayadi", async () => {
    const o = xotiraOmbori();
    await qoshish(o, { nomi: "Olma", narx: 12000, soni: 10 });
    await sotish(o, 1, 3, karta);

    const m = await o.topish(1);
    assert.equal(m?.soni, 7);
  });

  it("yetarli bolmasa rad etadi", async () => {
    const o = xotiraOmbori();
    await qoshish(o, { nomi: "Olma", narx: 12000, soni: 2 });

    const r = await sotish(o, 1, 5, karta);
    assert.equal(r.ok, false);
    assert.equal(r.ok ? "" : r.xato, "omborda yetarli emas: 2");
  });

  it("kam pul berilsa rad etadi", async () => {
    const o = xotiraOmbori();
    await qoshish(o, { nomi: "Anor", narx: 25000, soni: 5 });

    const r = await sotish(o, 1, 2, naqd);
    assert.equal(r.ok ? "" : r.xato, "kam berildi: 40000 < 50000");
  });

  it("mahsulot yoq bolsa rad etadi", async () => {
    const o = xotiraOmbori();
    const r = await sotish(o, 99, 1, karta);
    assert.equal(r.ok ? "" : r.xato, "mahsulot topilmadi: 99");
  });
});

node --import tsx --test src/xizmat.test.ts 2>&1 \
  | grep -E '^(ok|not ok|# (tests|pass|fail))'

import { tekshir } from "./tekshir.js";
import type { Mahsulot, YangiMahsulot } from "./turlar.js";

const a: YangiMahsulot = { nomi: "Olma", narx: 12000, soni: 1 };

// @ts-expect-error - YangiMahsulot da id yoq
const b: YangiMahsulot = { id: 1, nomi: "Olma", narx: 1, soni: 1 };

declare const m: Mahsulot;
// @ts-expect-error - id readonly
m.id = 2;

const r = tekshir({});
// @ts-expect-error - avval ok tekshirilishi kerak
r.qiymat;

console.log(a.nomi);
export {};

tsc --noEmit && echo "tur sinovi otdi"

import { xotiraOmbori } from "./ombor.js";
import { qoshish, sotish } from "./xizmat.js";
import type { Tolov } from "./turlar.js";

const ombor = xotiraOmbori();

const kirish: unknown[] = [
  { nomi: "Olma", narx: 12000, soni: 10 },
  { nomi: "Anor", narx: 25000, soni: 4 },
  { nomi: "", narx: 5000, soni: 1 },
  { nomi: "Uzum", narx: -1, soni: 1 },
  "mahsulot emas",
];

for (const x of kirish) {
  const r = await qoshish(ombor, x);
  console.log(r.ok ? `+ #${r.qiymat.id} ${r.qiymat.nomi}` : `- ${r.xato}`);
}

console.log("---");

const sotuvlar: Array<{ id: number; soni: number; tolov: Tolov }> = [
  { id: 1, soni: 3, tolov: { usul: "naqd", berilgan: 40000 } },
  { id: 2, soni: 2, tolov: { usul: "karta", raqam: "8600" } },
  { id: 1, soni: 99, tolov: { usul: "karta", raqam: "8600" } },
];

for (const s of sotuvlar) {
  const r = await sotish(ombor, s.id, s.soni, s.tolov);
  console.log(r.ok ? `+ ${r.qiymat}` : `- ${r.xato}`);
}

console.log("---");

for (const m of await ombor.hammasi()) {
  console.log(`#${m.id} ${m.nomi}: ${m.soni} dona`);
}

export {};

tsx src/asosiy.ts

node --import tsx --test "src/*.test.ts" 2>&1 \
  | grep -E '^(ok|not ok|# (tests|pass|fail))'
echo "--- qurish ---"
tsc
ls dist
echo "--- qurilgan dasturni ishga tushirish ---"
node dist/asosiy.js | tail -4

import { xotiraOmbori } from "./ombor.js";

const ombor = xotiraOmbori();
const hammasi = await ombor.hammasi();

const birinchi = hammasi[0];
console.log(birinchi.nomi);

export {};

tsc --noEmit 2>&1 | fold -sw 74
rm -f src/xato.ts

tsc --noEmit && echo "tsc: xato yo_q"
ls src