pool.js

(function(global){
  'use strict';

  const utils = global.HAMLEARN_UTILS || {};
  if (!utils || typeof utils.parsePlainTextPool !== 'function') {
    throw new Error('HAMLEARN_UTILS.parsePlainTextPool must be loaded before pool.js.');
  }

  const parsePlainTextPool = utils.parsePlainTextPool;
  const fetchRef = typeof global.fetch === 'function' ? global.fetch.bind(global) : null;

  if (!fetchRef) {
    throw new Error('Fetch API is unavailable. A modern browser environment is required.');
  }

  const registry = new Map();

  const ensurePromise = (value) => (value && typeof value.then === 'function' ? value : Promise.resolve(value));

  const fetchText = (url) => fetchRef(url).then((response) => {
    if (!response.ok) {
      throw new Error(`Failed to load question pool from "${url}".`);
    }
    return response.text();
  });

  const createTextLoader = (url, options = {}) => {
    const { parserOptions = {}, expectedMinimum = 1 } = options;
    return () => fetchText(url).then((text) => {
      const questions = parsePlainTextPool(text, parserOptions);
      if (expectedMinimum && Array.isArray(questions) && questions.length < expectedMinimum) {
        throw new Error(`Question pool "${url}" appears incomplete.`);
      }
      return questions;
    });
  };

  const register = (name, loader) => {
    if (!name) {
      throw new Error('A pool name is required for registration.');
    }
    if (typeof loader !== 'function') {
      throw new Error(`Pool loader for "${name}" must be a function.`);
    }
    registry.set(name, { loader, cache: null });
  };

  const ensureEntry = (name) => {
    if (!registry.has(name)) {
      throw new Error(`Unknown question pool "${name}".`);
    }
    return registry.get(name);
  };

  const load = (name) => {
    const entry = ensureEntry(name);
    if (entry.cache) {
      return Promise.resolve(entry.cache);
    }
    return ensurePromise(entry.loader()).then((questions) => {
      entry.cache = questions;
      return questions;
    });
  };

  const preload = (name) => load(name).then(() => true);

  const clear = (name) => {
    if (!name) {
      registry.forEach((entry) => {
        entry.cache = null;
      });
      return;
    }
    if (registry.has(name)) {
      registry.get(name).cache = null;
    }
  };

  const api = {
    register,
    load,
    preload,
    clear,
    createTextLoader,
  };

  api.register('technician', api.createTextLoader('Technician Pool.txt', {
    expectedMinimum: 400,
  }));

  api.register('general', api.createTextLoader('General pool.txt', {
    expectedMinimum: 400,
  }));

  api.register('extra', api.createTextLoader('Extra pool.txt', {
    expectedMinimum: 500,
  }));

  global.HAMLEARN_POOL = api;
})(typeof window !== 'undefined' ? window : globalThis);