@miso.ai/lorem 0.9.1-beta.19 → 0.10.0-beta.1

package/bin/data.js

@@ -6,7 +6,7 @@ import yaml from 'js-yaml';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const WORDS_YAML = resolve(__dirname, '../data/words.yaml');
-const WORDS_JS = resolve(__dirname, '../lib/words.js');
+const WORDS_JS = resolve(__dirname, '../lib/wordbank.js');
 
 const words = yaml.load(readFileSync(WORDS_YAML, 'utf8'));
 writeFileSync(WORDS_JS, `

package/lib/fields.js

@@ -1,114 +1,129 @@
-import * as lorem from './lorem.js';
-import { imageUrl, sample } from './utils.js';
-import * as md from './markdown.js';
-
-const DAY = 1000 * 60 * 60 * 24;
-const WEEK = DAY * 7;
-
-export function date({} = {}) {
-  const now = Date.now();
-  const max = now - DAY;
-  const min = max - WEEK * 8;
-  return new Date(min + Math.random() * (max - min)).toISOString();
-}
+// 2025 date range for random date generation
+const DATE_MIN = Date.UTC(2025, 0, 1);  // 2025-01-01
+const DATE_MAX = Date.UTC(2025, 11, 31, 23, 59, 59, 999);  // 2025-12-31
 
-export function image({ size = 300 } = {}) {
-  return imageUrl(size);
-}
+export class Fields {
 
-export function authors({ size = [1, 3] } = {}) {
-  return lorem.lorem({
-    size,
-    decorates: ['title'],
-    output: 'array',
-  });
-}
+  constructor(lorem) {
+    this._prng = lorem._prng;
+    this._words = lorem.words;
+    this._markdown = lorem.markdown;
+  }
 
-export function tags({ size = [1, 4] } = {}) {
-  return lorem.lorem({
-    size,
-    output: 'array',
-  });
-}
+  date({} = {}) {
+    return new Date(DATE_MIN + this._prng.random() * (DATE_MAX - DATE_MIN)).toISOString();
+  }
 
-// TODO: categories
+  image({ size = 300 } = {}) {
+    return this._imageUrl(size);
+  }
 
-export function title({ size = [2, 6] } = {}) {
-  return lorem.lorem({
-    size,
-    decorates: ['title'],
-  });
-}
+  authors({ size = [1, 3] } = {}) {
+    return this._words.words({
+      size,
+      decorates: ['title'],
+      output: 'array',
+    });
+  }
 
-export function term({ field }) {
-  const random = Math.random();
-  const size = random < 0.7 ? 1 : random < 0.9 ? 2 : 3;
-  return lorem.lorem({
-    size,
-    decorates: ['title'],
-  });
-}
+  tags({ size = [1, 4] } = {}) {
+    return this._words.words({
+      size,
+      output: 'array',
+    });
+  }
 
-export function description({ size = [10, 20], ...options } = {}) {
-  const decorator = Object.keys(options).length ? ['description', options] : 'description';
-  return lorem.lorem({
-    size,
-    decorates: [decorator],
-  });
-}
+  // TODO: categories
+
+  title({ size = [2, 6] } = {}) {
+    return this._words.words({
+      size,
+      decorates: ['title'],
+    });
+  }
+
+  term({ field } = {}) {
+    const random = this._prng.random();
+    const size = random < 0.7 ? 1 : random < 0.9 ? 2 : 3;
+    return this._words.words({
+      size,
+      decorates: ['title'],
+    });
+  }
 
-export function html({ paragraphs = 8, sections, paragraph, image: imageOptions } = {}) {
-  paragraph = {
-    size: [30, 60],
-    ...paragraph,
-  };
-  imageOptions = {
-    size: [480, 270],
-    ...imageOptions,
-  };
-  if (sections === undefined) {
-    sections = Math.floor(paragraphs * (1 + Math.random()) / 4);
+  description({ size = [10, 20], ...options } = {}) {
+    const decorator = Object.keys(options).length ? ['description', options] : 'description';
+    return this._words.words({
+      size,
+      decorates: [decorator],
+    });
   }
-  sections = Math.max(1, Math.min(sections, paragraphs));
-  const content = [];
-  const pps = paragraphs / sections;
-  let j = 0;
-  for (let i = 0; i < sections; i++) {
-    if (i > 0) {
-      content.push(`<h4>${title()}</h4>`);
+
+  html({ paragraphs = 8, sections, paragraph, image: imageOptions } = {}) {
+    paragraph = {
+      size: [30, 60],
+      ...paragraph,
+    };
+    imageOptions = {
+      size: [480, 270],
+      ...imageOptions,
+    };
+    if (sections === undefined) {
+      sections = Math.floor(paragraphs * (1 + this._prng.random()) / 4);
     }
-    while (j++ < (i + 1) * pps) {
-      content.push(`<p>${description(paragraph)}</p>`);
+    sections = Math.max(1, Math.min(sections, paragraphs));
+    const content = [];
+    const pps = paragraphs / sections;
+    let j = 0;
+    for (let i = 0; i < sections; i++) {
+      if (i > 0) {
+        content.push(`<h4>${this.title()}</h4>`);
+      }
+      while (j++ < (i + 1) * pps) {
+        content.push(`<p>${this.description(paragraph)}</p>`);
+      }
+      content.push(`<div class="image-container"><img src="${this.image(imageOptions)}"></div>`);
     }
-    content.push(`<div class="image-container"><img src="${image(imageOptions)}"></div>`);
+    return content.join('');
   }
-  return content.join('');
-}
 
-export function availability() {
-  return Math.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
-}
+  availability() {
+    return this._prng.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
+  }
 
-export function price() {
-  return Math.floor(Math.random() * 10000) / 100;
-}
+  price() {
+    return Math.floor(this._prng.random() * 10000) / 100;
+  }
 
-export function rating() {
-  return Math.floor(Math.random() * 500) / 100 + 1;
-}
+  rating() {
+    return Math.floor(this._prng.random() * 500) / 100 + 1;
+  }
+
+  answer({ sources, format, citation, sampling, features }) {
+    switch (format) {
+      case 'markdown':
+        let index = 1;
+        sources = sources.map(({ url }) => ({ url, index: index++ }));
+        return this._markdown.markdown({ sources, citation, sampling, features });
+      case 'plaintext':
+      default:
+        return this._words.words({
+          min: this._sample(50, sampling),
+          max: this._sample(50, sampling),
+          decorates: ['description'],
+        });
+    }
+  }
 
-export function answer({ sources, format, citation, sampling, features }) {
-  switch (format) {
-    case 'markdown':
-      let index = 1;
-      sources = sources.map(({ url }) => ({ url, index: index++ }));
-      return md.markdown({ sources, citation, sampling, features });
-    case 'plaintext':
-    default:
-      return lorem.lorem({
-        min: sample(50, sampling),
-        max: sample(50, sampling),
-        decorates: ['description'],
-      });
+  // helpers //
+  _imageUrl(size) {
+    const seed = this._prng.randomInt(0, 999);
+    const sizePath = Array.isArray(size) ? size.length > 1 ? `${size[0]}/${size[1]}` : `${size[0]}` : `${size}`;
+    return `https://picsum.photos/seed/${seed}/${sizePath}`;
   }
+
+  _sample(size, sampling) {
+    return sampling !== undefined ? Math.ceil(size * sampling) : size;
+  }
+
 }

package/lib/index.js

@@ -1,6 +1,9 @@
-import * as md from './markdown.js';
-import * as lorem from './lorem.js';
-import * as utils from './utils.js';
-import * as fields from './fields.js';
+// Main entry point - creates a seeded Lorem instance with all utilities attached
+export * from './lorem.js';
 
-export { md, lorem, utils, fields };
+// Export classes for direct use if needed
+export { Words } from './words.js';
+export { Markdown as Md } from './markdown.js';
+export { Fields } from './fields.js';
+export { Utils } from './utils.js';
+export { randomSeed } from './prng.js';

package/lib/lorem.js

@@ -1,145 +1,36 @@
-import { randomInt, gaussRandom, iterateWithLastItemSignal as iterateWithLastItemSignal } from './utils.js';
-import DEFAULT_WORDS from './words.js';
+import { prng } from './prng.js';
+import { Words } from './words.js';
+import { Markdown } from './markdown.js';
+import { Fields } from './fields.js';
+import { Utils } from './utils.js';
+import { randomSeed } from './prng.js';
 
-export function lorem({ decorates = [], output = 'string', size, min, max, ...options } = {}) {
-  let iterator = limit(size || [min, max])(base(options));
-  for (const decorate of decorates) {
-    iterator = lookup(decorate)(iterator);
-  }
-  return lookup(output)(iterator);
+export function lorem(options) {
+  return new Lorem(options);
 }
 
-const FNS = {
-  string,
-  array,
-  title,
-  description,
-  multiline,
-}
+class Lorem {
 
-function lookup(fn) {
-  switch (typeof fn) {
-    case 'string':
-      return FNS[fn]();
-    case 'function':
-      return fn;
-    case 'object':
-      if (Array.isArray(fn)) {
-        const [name, options = {}] = fn;
-        return FNS[name](options);
-      }
-  }
-  throw new Error(`Unrecognized decorator/output form: ${fn}`);
-}
+  constructor({ seed = randomSeed() } = {}) {
+    this._seed = seed;
+    this._prng = prng({ seed });
 
-// base //
-export function *base({ words = DEFAULT_WORDS, fixedStarts = 0 } = {}) {
-  const wordsLength = words.length;
-  for (let i = 0; ; i++) {
-    yield words[i < fixedStarts ? i : Math.floor(Math.random() * wordsLength)];
+    // Initialize in dependency order:
+    // utils and words have no dependencies on other classes
+    // markdown depends on words
+    // fields depends on words and markdown
+    this.utils = new Utils(this);
+    this.words = new Words(this);
+    this.markdown = new Markdown(this);
+    this.fields = new Fields(this);
   }
-}
-
-// output //
-export function string({ separator = ' ' } = {}) {
-  return iterator => [...iterator].join(separator);
-}
-
-export function array() {
-  return iterator => [...iterator];
-}
 
-export function multiline({
-  wordsPerLine = {
-    avg: 10,
-    std: 3,
-    min: 1,
-  },
-} = {}) {
-  return iterator => {
-    let slen = gaussMS(wordsPerLine);
-    let result = '';
-    for (let word of iterator) {
-      if (result) {
-        if (slen-- === 0) {
-          result += '\n';
-          slen = gaussMS(wordsPerLine);
-        } else {
-          result += ' ';
-        }
-      }
-      result += word;
-    }
-    return result;
+  get prng() {
+    return this._prng;
   }
-}
-
-// decorators //
-export function limit(size = [5, 10]) {
-  const n = typeof size === 'number' ? size : randomInt(...size);
-  return function *(iterator) {
-    let i = 0;
-    for (let word of iterator) {
-      if (i++ >= n) {
-        break;
-      }
-      yield word;
-    }
-  };
-}
 
-export function title({} = {}) {
-  return function *(iterator) {
-    for (let word of iterator) {
-      yield capitalize(word);
-    }
-  };
-}
-
-export function description({
-  wordsPerSentence = {
-    avg: 24,
-    std: 5,
-    min: 1,
-  },
-  punctuation = '.',
-} = {}) {
-  return function *(iterator) {
-    let slen = 0;
-
-    yield* iterateWithLastItemSignal(iterator, function *(word, last) {
-      if (slen === 0) {
-        word = capitalize(word);
-        slen = gaussMS(wordsPerSentence);
-      }
-      if (--slen === 0 || last) {
-        word += punctuation;
-      }
-      yield word;
-    });
-  };
-}
-
-// helpers //
-function capitalize(word) {
-  return word[0].toUpperCase() + word.substring(1);
-}
-
-// TODO: have a random variable expression
-function gaussMS(args) {
-  if (typeof args === 'number') {
-    return Math.round(avg);
-  }
-  let { avg, std, min, max } = args;
-  if (std === undefined) {
-    std = avg / 4;
-  }
-  let n = gaussRandom() * std + avg;
-  if (min !== undefined) {
-    n = Math.max(min, n);
+  get seed() {
+    return this._seed;
   }
-  if (max !== undefined) {
-    n = Math.min(max, n);
-  }
-  return Math.round(n);
+
 }