@abc/core

Core package containing essential functions and data processing logic for the ABC system.

📦 Installation

pnpm add @abc/core

🚀 Key Features

Â

1. Test Data Processing

• Create and manage different types of tests (practice, final, diagnostic)
• Process test data with different game modes
• Automatically generate diagnostic tests based on topics and questions

2. Topics Management

• Process and map topics with test data
• Generate slugs for topics
• Calculate average level of topics

3. Branch Test

• Handle branch tests for special applications (like ASVAB)
• Create branched test structures

4. Utilities

• Generate random IDs
• Fetch questions from API
• Create group exam data
• Process questions by topics

📚 API Reference

Test Processing

processTestData(options)

Process test data and create different types of tests.

import { processTestData } from "@abc/core";

const result = await processTestData({
  topics: ITopic[],
  tests: ITestData,
  questions: IQuestion[],
  appShortName: string,
  state?: string
});

handleGetBranchTest(options)

Handle branch tests for special applications.

import { handleGetBranchTest } from "@abc/core";

const { data, slugsBranch } = await handleGetBranchTest({
  topics: ITopic[],
  questions: IQuestion[],
  appShortName: string
});

getDiagnosticTest(topics, questions)

Automatically generate diagnostic tests.

import { getDiagnosticTest } from "@abc/core";

const diagnosticTest = getDiagnosticTest(topics, questions);

Topics Processing

processTopics(options)

Process topics and generate slugs.

import { processTopics } from "@abc/core";

const { slugsTopic, questions, listTopics } = await processTopics({
  topics: ITopic[],
  app: string,
  state?: string,
  isParent?: boolean
});

mapTopicsAndTest(options)

Map topics with test data.

import { mapTopicsAndTest } from "@abc/core";

const { questions, topics } = mapTopicsAndTest({
  data: IData[],
  topic: ITopic,
  slug: string
});

calculateAverageLevelTopic(topics)

Calculate average level of topics.

import { calculateAverageLevelTopic } from "@abc/core";

const averageLevel = calculateAverageLevelTopic(topics);

Utilities

generateRandomId()

Generate random ID.

import { generateRandomId } from "@abc/core";

const id = generateRandomId(); // "abc123def456"

generateRandomNegativeId(exclude?)

Generate random negative ID.

import { generateRandomNegativeId } from "@abc/core";

const negativeId = generateRandomNegativeId(-1); // -123456

getQuestionByTopics(id, app, state?)

Fetch questions from API by topic ID.

import { getQuestionByTopics } from "@abc/core";

const questions = await getQuestionByTopics(123, "asvab", "california");

getRandomQuestion(questions)

Get random question from list.

import { getRandomQuestion } from "@abc/core";

const randomQuestion = getRandomQuestion(questions);

generateGroupExamData(options)

Generate group exam data from topics and questions.

import { generateGroupExamData } from "@abc/core";

const groupData = generateGroupExamData({
  topics: ITopic[],
  questions: IQuestion[],
  currentIndex?: number
});

fetchQuestionsForTopics(options)

Fetch questions for multiple topics.

import { fetchQuestionsForTopics } from "@abc/core";

const questions = await fetchQuestionsForTopics({
  selectListTopic: ITopic[],
  target: number,
  excludeListID?: number[],
  isHard?: boolean,
  questions: IQuestion[]
});

🧪 Testing

# Run tests
pnpm test

# Run tests with coverage
pnpm test:coverage

# Run tests once
pnpm test:run

🔧 Development

# Build package
pnpm build

# Development mode
pnpm dev

# Clean dist
pnpm clean

📦 Dependencies

Production Dependencies

• axios - HTTP client
• commander - CLI framework
• node-fetch - Fetch API
• p-limit - Concurrency control
• uuid - UUID generation
• abc-model - Data models
• abc-constants - Constants
• abc-router - Routing utilities

Development Dependencies

• @repo/eslint-config - ESLint configuration
• @types/node - Node.js types
• vitest - Testing framework
• @repo/mock - Mocking utilities
• @vitest/coverage-v8 - Coverage reporting
• jsdom - DOM environment for tests

📄 License

MIT