k9guard 1.0.3 → 1.0.4

package/src/utils/reverseGenerator.ts

@@ -1,54 +0,0 @@
-import { randomBytes } from './crypto';
-
-export class ReverseGenerator {
-  private static readonly easyWords = [
-    'cat', 'dog', 'sun', 'moon', 'star', 'fish', 'bird', 'tree',
-    'ball', 'book', 'door', 'lamp', 'rock', 'leaf', 'wind', 'fire',
-    'ice', 'sky', 'sea', 'fog', 'rain', 'snow', 'bear', 'wolf',
-    'coin', 'key', 'cup', 'pen', 'box', 'hat', 'map', 'web'
-  ];
-
-  private static readonly mediumWords = [
-    'apple', 'house', 'water', 'bread', 'ocean', 'river', 'tiger', 'eagle',
-    'storm', 'cloud', 'flame', 'frost', 'stone', 'metal', 'glass', 'paper',
-    'forest', 'desert', 'valley', 'castle', 'bridge', 'garden', 'market', 'temple',
-    'dragon', 'wizard', 'knight', 'shield', 'sword', 'crown', 'jewel', 'crystal',
-    'planet', 'galaxy', 'comet', 'nebula', 'cipher', 'enigma', 'puzzle', 'riddle',
-    'shadow', 'mirror', 'portal', 'beacon', 'anchor', 'compass', 'lantern', 'prism'
-  ];
-
-  private static readonly hardWords = [
-    'typescript', 'javascript', 'encryption', 'cryptography', 'algorithm', 'infrastructure',
-    'architecture', 'authentication', 'authorization', 'vulnerability', 'cybersecurity',
-    'blockchain', 'metamorphosis', 'constellation', 'synchronization', 'transformation',
-    'illumination', 'orchestration', 'denomination', 'comprehension', 'manifestation',
-    'extraordinary', 'revolutionary', 'sophisticated', 'kaleidoscope', 'optimization',
-    'crystallization', 'configuration', 'implementation', 'parallelization', 'serialization',
-    'decentralization', 'internationalization', 'containerization', 'virtualization',
-    'obfuscation', 'triangulation', 'interpolation', 'extrapolation', 'approximation',
-    'segmentation', 'fragmentation', 'concatenation', 'regeneration', 'degeneration'
-  ];
-
-  static generate(difficulty: 'easy' | 'medium' | 'hard'): { question: string; answer: string } {
-    let wordPool: string[];
-    
-    if (difficulty === 'easy') {
-      wordPool = this.easyWords;
-    }
-    
-    if (difficulty === 'medium') {
-      wordPool = this.mediumWords;
-    }
-    
-    if (difficulty === 'hard') {
-      wordPool = this.hardWords;
-    }
-    
-    const buf = randomBytes(4);
-    const rand = buf.readUInt32LE(0) / 0xFFFFFFFF;
-    const text = wordPool![Math.floor(rand * wordPool!.length)]!;
-    const reversed = text.split('').reverse().join('');
-    
-    return { question: reversed, answer: text };
-  }
-}

package/src/utils/scrambleGenerator.ts

@@ -1,49 +0,0 @@
-import { randomBytes } from './crypto';
-
-export class ScrambleGenerator {
-  private static readonly easyWords: string[] = [
-    'apple', 'cat', 'dog', 'house', 'sun', 'moon', 'car', 'tree', 'book', 'water'
-  ];
-
-  private static readonly mediumWords: string[] = [
-    'apple', 'cat', 'dog', 'house', 'sun', 'moon', 'car', 'tree', 'book', 'water',
-    'bread', 'milk', 'fish', 'bird', 'flower', 'star', 'hand', 'eye', 'nose', 'mouth'
-  ];
-
-  // hard pool: longer words with uncommon letter patterns to resist guessing
-  private static readonly hardWords: string[] = [
-    'typescript', 'javascript', 'algorithm', 'encryption', 'blockchain',
-    'metamorphosis', 'cryptography', 'synchronize', 'parallelism', 'obfuscation',
-    'infrastructure', 'authentication', 'authorization', 'vulnerability', 'orchestration'
-  ];
-
-  static generate(difficulty: 'easy' | 'medium' | 'hard'): { question: string; answer: string } {
-    let pool: string[];
-    if (difficulty === 'easy') {
-      pool = this.easyWords;
-    } else if (difficulty === 'medium') {
-      pool = this.mediumWords;
-    } else {
-      pool = this.hardWords;
-    }
-
-    const buffer = randomBytes(4);
-    const rand = buffer.readUInt32LE(0) / 0xFFFFFFFF;
-    const word = pool[Math.floor(rand * pool.length)]!;
-    
-    const scrambled = this.scramble(word);
-    return { question: scrambled, answer: word };
-  }
-
-  private static scramble(word: string): string {
-    const arr = word.split('');
-    const n   = arr.length;
-    // batch all uint32 values for Fisher-Yates in one crypto call (n-1 swaps × 4 bytes)
-    const batchBuf = randomBytes(n * 4);
-    for (let i = n - 1; i > 0; i--) {
-      const j = batchBuf.readUInt32LE((n - 1 - i) * 4) % (i + 1);
-      [arr[i]!, arr[j]!] = [arr[j]!, arr[i]!];
-    }
-    return arr.join('');
-  }
-}

package/src/utils/sequenceGenerator.ts

@@ -1,34 +0,0 @@
-import { randomBytes } from './crypto';
-
-export class SequenceGenerator {
-  static generate(difficulty: 'easy' | 'medium' | 'hard'): { question: string; answer: number | string } {
-    if (difficulty === 'easy') {
-      const buffer = randomBytes(8);
-      // use separate byte ranges for start and step to remove correlation between them
-      const start = (buffer.readUInt32LE(0) % 5) + 1;
-      const step = (buffer.readUInt32LE(4) % 3) + 1;
-      const sequence = [start, start + step, start + 2 * step];
-      const answer = start + 3 * step;
-      return { question: `${sequence.join(', ')}, ?`, answer };
-    }
-    if (difficulty === 'medium') {
-      const letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'];
-      const step = 2;
-      // max start ensures all 4 elements (start, +2, +4, +6) fit within the 10-letter array
-      const maxStart = letters.length - step * 3 - 1;
-      const buffer = randomBytes(4);
-      const start = buffer.readUInt32LE(0) % (maxStart + 1);
-      const sequence = [letters[start], letters[start + step], letters[start + 2 * step]];
-      const answer = letters[start + 3 * step]!;
-      return { question: `${sequence.join(', ')}, ?`, answer };
-    }
-    // hard: pick a random starting offset in the Fibonacci sequence so the answer is not always 5
-    const fibs = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144];
-    const buffer = randomBytes(4);
-    const maxStart = fibs.length - 5; // ensure 4 shown + 1 answer all fit
-    const start = buffer.readUInt32LE(0) % (maxStart + 1);
-    const sequence = fibs.slice(start, start + 4);
-    const answer = fibs[start + 4]!;
-    return { question: `${sequence.join(', ')}, ?`, answer };
-  }
-}

package/src/validators/customQuestionValidator.ts

@@ -1,88 +0,0 @@
-import type { CustomQuestion } from '../types';
-
-export class CustomQuestionValidator {
-  private static readonly MAX_QUESTIONS = 100;
-  private static readonly MAX_QUESTION_LENGTH = 500;
-  private static readonly MAX_ANSWER_LENGTH = 200;
-  private static readonly MIN_QUESTION_LENGTH = 5;
-  private static readonly MIN_ANSWER_LENGTH = 1;
-  private static readonly VALID_DIFFICULTY = ['easy', 'medium', 'hard'];
-
-  // validates the entire questions array structure and content
-  static validate(questions: unknown): { valid: boolean; error?: string } {
-    if (!Array.isArray(questions)) {
-      return { valid: false, error: 'Questions must be an array' };
-    }
-
-    if (questions.length === 0) {
-      return { valid: false, error: 'At least one question is required' };
-    }
-
-    if (questions.length > this.MAX_QUESTIONS) {
-      return { valid: false, error: `Maximum ${this.MAX_QUESTIONS} questions allowed` };
-    }
-
-    // NOTE: validate each question individually and return detailed error if any fail
-    for (let i = 0; i < questions.length; i++) {
-      const questionItem = questions[i];
-      const singleValidation = this.validateSingle(questionItem);
-      
-      if (!singleValidation.valid) {
-        return { valid: false, error: `Question ${i + 1}: ${singleValidation.error}` };
-      }
-    }
-
-    return { valid: true };
-  }
-
-  private static validateSingle(question: unknown): { valid: boolean; error?: string } {
-    if (typeof question !== 'object' || question === null) {
-      return { valid: false, error: 'Each question must be an object' };
-    }
-
-    const q = question as Record<string, unknown>;
-
-    if (typeof q.question !== 'string') {
-      return { valid: false, error: 'Question text must be a string' };
-    }
-
-    if (typeof q.answer !== 'string') {
-      return { valid: false, error: 'Answer must be a string' };
-    }
-
-    if (typeof q.difficulty !== 'string') {
-      return { valid: false, error: 'Difficulty must be specified' };
-    }
-
-    if (!this.VALID_DIFFICULTY.includes(q.difficulty)) {
-      return { valid: false, error: `Difficulty must be one of: ${this.VALID_DIFFICULTY.join(', ')}` };
-    }
-
-    if (q.question.length < this.MIN_QUESTION_LENGTH) {
-      return { valid: false, error: `Question must be at least ${this.MIN_QUESTION_LENGTH} characters` };
-    }
-
-    if (q.question.length > this.MAX_QUESTION_LENGTH) {
-      return { valid: false, error: `Question must not exceed ${this.MAX_QUESTION_LENGTH} characters` };
-    }
-
-    if (q.answer.length < this.MIN_ANSWER_LENGTH) {
-      return { valid: false, error: 'Answer cannot be empty' };
-    }
-
-    if (q.answer.length > this.MAX_ANSWER_LENGTH) {
-      return { valid: false, error: `Answer must not exceed ${this.MAX_ANSWER_LENGTH} characters` };
-    }
-
-    return { valid: true };
-  }
-
-  // clean up whitespace from questions and answers
-  static sanitize(questions: CustomQuestion[]): CustomQuestion[] {
-    return questions.map(q => ({
-      question: q.question.trim(),
-      answer: q.answer.trim(),
-      difficulty: q.difficulty
-    }));
-  }
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}