poutine-ipsum 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 felixlechat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# poutine-ipsum
+
+[![CI](https://github.com/felixlechat/poutine-ipsum/actions/workflows/ci.yml/badge.svg)](https://github.com/felixlechat/poutine-ipsum/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/poutine-ipsum)](https://www.npmjs.com/package/poutine-ipsum)
+[![license](https://img.shields.io/npm/l/poutine-ipsum)](./LICENSE)
+
+`poutine-ipsum` is an npm library that generates Lorem Ipsum-like placeholder text about poutine.
+
+It mimics the API style of the most-starred comparable JavaScript lorem library (`knicklabs/lorem-ipsum.js`) by exposing:
+
+- A class API for repeated generation with shared options.
+- A function API for one-off text generation.
+
+Supported languages:
+
+- `en` (English)
+- `fr` (French)
+
+All generated outputs always begin with:
+
+`Poutine ipsum dolor sit amet`
+
+## Installation
+
+```bash
+npm install poutine-ipsum
+```
+
+## Using the Class
+
+```js
+import { PoutineIpsum } from "poutine-ipsum";
+
+const poutine = new PoutineIpsum({
+  language: "fr",
+  sentencesPerParagraph: {
+    min: 2,
+    max: 4,
+  },
+  wordsPerSentence: {
+    min: 4,
+    max: 10,
+  },
+});
+
+console.log(poutine.generateWords(5));
+console.log(poutine.generateSentences(2));
+console.log(poutine.generateParagraphs(3));
+```
+
+### Class Options
+
+- `language`: `"en" | "fr"` (default: `"fr"`)
+- `vocabulary`: `"classic" | "extended" | "all"` (default: `"all"`) — `"classic"` uses only traditional poutine terms (fries, gravy, curds, …), `"extended"` uses only toppings and variations (smoked meat, foie gras, merguez, …), `"all"` combines both
+- `sentencesPerParagraph.min`: number (default: `3`)
+- `sentencesPerParagraph.max`: number (default: `7`)
+- `wordsPerSentence.min`: number (default: `5`)
+- `wordsPerSentence.max`: number (default: `15`)
+- `random`: PRNG function (default: `Math.random`)
+- `suffix`: paragraph separator string (default: OS-specific line ending)
+- `words`: optional custom word list array (overrides language dictionary)
+
+## Using the Function
+
+```js
+import { poutineIpsum } from "poutine-ipsum";
+
+const text = poutineIpsum({
+  count: 2,
+  units: "paragraphs",
+  language: "en",
+});
+
+console.log(text);
+```
+
+### Function Options
+
+- `count`: number of units to generate (default: `1`)
+- `units`: `"word(s)" | "sentence(s)" | "paragraph(s)"` (default: `"sentences"`)
+- `format`: `"plain" | "html"` (HTML wraps paragraphs in `<p>` tags)
+- `language`: `"en" | "fr"` (default: `"fr"`)
+- `vocabulary`: `"classic" | "extended" | "all"` (default: `"all"`)
+- `paragraphLowerBound`: min sentences per paragraph (default: `3`)
+- `paragraphUpperBound`: max sentences per paragraph (default: `7`)
+- `sentenceLowerBound`: min words per sentence (default: `5`)
+- `sentenceUpperBound`: max words per sentence (default: `15`)
+- `suffix`: separator between generated units (default: OS-specific line ending)
+- `random`: PRNG function (default: `Math.random`)
+- `words`: optional custom words array
+
+## Examples
+
+English words:
+
+```js
+poutineIpsum({ count: 8, units: "words", language: "en" });
+// "Poutine ipsum dolor sit amet curds saucebrune ..."
+```
+
+French sentence (default language):
+
+```js
+poutineIpsum({ count: 1, units: "sentences" });
+// "Poutine ipsum dolor sit amet ..."
+```
+
+Classic vocabulary only:
+
+```js
+poutineIpsum({ count: 1, units: "sentences", vocabulary: "classic" });
+// "Poutine ipsum dolor sit amet crispy golden cheddar ..."
+```
+
+HTML paragraphs:
+
+```js
+poutineIpsum({ count: 2, units: "paragraphs", format: "html" });
+// "<p>...</p>\n<p>...</p>"
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+[MIT](./LICENSE)
+
+## Author
+
+Created by [felixlechat](https://github.com/felixlechat).

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "poutine-ipsum",
+  "version": "0.1.0",
+  "description": "Generate Lorem Ipsum-like placeholder text about poutine in French or English.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "lint": "eslint .",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.js": "eslint"
+  },
+  "keywords": [
+    "lorem",
+    "ipsum",
+    "poutine",
+    "generator"
+  ],
+  "author": "felixlechat",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/felixlechat/poutine-ipsum.git"
+  },
+  "homepage": "https://github.com/felixlechat/poutine-ipsum#readme",
+  "bugs": "https://github.com/felixlechat/poutine-ipsum/issues",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.1.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/dictionaries.js

@@ -0,0 +1,171 @@
+export const DICTIONARIES = {
+  en: {
+    classic: [
+      "poutine",
+      "fries",
+      "gravy",
+      "curd",
+      "curds",
+      "cheddar",
+      "squeaky",
+      "brown sauce",
+      "velvety",
+      "peppery",
+      "stock",
+      "beef stock",
+      "chicken stock",
+      "casse-croute",
+      "cantine",
+      "chip wagon",
+      "poutinerie",
+      "quebec",
+      "quebecois",
+      "montreal",
+      "drummondville",
+      "warwick",
+      "victoriaville",
+      "classic",
+      "authentic",
+      "fresh cut",
+      "crispy",
+      "golden",
+      "double fried",
+      "steamy",
+      "melty",
+      "savory",
+      "comfort",
+      "street food",
+      "festival",
+      "hearty",
+      "hot",
+      "messy",
+      "forkful",
+      "bite",
+      "late hour",
+    ],
+    extended: [
+      "galvaude",
+      "italian",
+      "smoked meat",
+      "sausage",
+      "spicy sausage",
+      "onion",
+      "lardon",
+      "bacon",
+      "mushroom",
+      "green peas",
+      "peppers",
+      "tomatoes",
+      "pickles",
+      "onion rings",
+      "ground steak",
+      "pepperoni",
+      "merguez",
+      "grilled chicken",
+      "hot dog",
+      "pogo",
+      "shredded pork",
+      "brisket",
+      "duck",
+      "foie gras",
+      "truffle",
+      "demi-glace",
+      "au jus",
+      "guacamole",
+      "sour cream",
+      "Swiss cheese",
+      "loaded",
+      "garnished",
+    ],
+  },
+  fr: {
+    classic: [
+      "poutine",
+      "frites",
+      "sauce",
+      "saucebrune",
+      "fromage",
+      "fromage en grain",
+      "squick",
+      "croquante",
+      "croustillante",
+      "dorée",
+      "doublecuisson",
+      "poivrée",
+      "veloutée",
+      "bouillon",
+      "boeuf",
+      "poulet",
+      "cassecroûte",
+      "cantine",
+      "poutinerie",
+      "montréal",
+      "québec",
+      "drummondville",
+      "warwick",
+      "victoriaville",
+      "authentique",
+      "classique",
+      "réconfort",
+      "vapeur",
+      "fumante",
+      "fondante",
+      "salée",
+      "savoureuse",
+      "riche",
+      "copieuse",
+      "gourmande",
+      "fringale",
+      "après bar",
+      "minuit",
+      "bouchée",
+      "fourchette",
+      "tablée",
+      "québécoise",
+      "terroir",
+      "rustique",
+      "artisanale",
+      "fromage patate sauce",
+      "savoureuse",
+      "tradition",
+      "patate",
+      "pomme de terre",
+      "fumée",
+      "poivre",
+      "maison",
+    ],
+    extended: [
+      "galvaude",
+      "italienne",
+      "all dressed",
+      "viande fumée",
+      "saucisse",
+      "saucisse épicée",
+      "lardon",
+      "champignon",
+      "petits pois",
+      "poivrons",
+      "oignons",
+      "tomates",
+      "cornichons",
+      "rondelles d'oignon",
+      "steak haché",
+      "pepperoni",
+      "merguez",
+      "poulet grillé",
+      "hot dog",
+      "pogo",
+      "porc effiloché",
+      "canard confit",
+      "foie gras",
+      "demi-glace",
+      "trois poivres",
+      "guacamole",
+      "crème sure",
+      "fromage suisse",
+      "garniture",
+      "extra fromage",
+      "mixte",
+    ],
+  },
+};

package/src/index.d.ts

@@ -0,0 +1,50 @@
+export interface Range {
+  min?: number;
+  max?: number;
+}
+
+export type Vocabulary = "classic" | "extended" | "all";
+
+export interface PoutineIpsumOptions {
+  language?: "en" | "fr";
+  vocabulary?: Vocabulary;
+  sentencesPerParagraph?: Range;
+  wordsPerSentence?: Range;
+  random?: () => number;
+  suffix?: string;
+  words?: string[];
+}
+
+export class PoutineIpsum {
+  constructor(options?: PoutineIpsumOptions);
+  generateWords(count?: number): string;
+  generateSentences(count?: number): string;
+  generateParagraphs(count?: number): string;
+}
+
+export type Units =
+  | "word"
+  | "words"
+  | "sentence"
+  | "sentences"
+  | "paragraph"
+  | "paragraphs";
+
+export interface PoutineIpsumFunctionOptions {
+  count?: number;
+  units?: Units;
+  format?: "plain" | "html";
+  language?: "en" | "fr";
+  vocabulary?: Vocabulary;
+  paragraphLowerBound?: number;
+  paragraphUpperBound?: number;
+  sentenceLowerBound?: number;
+  sentenceUpperBound?: number;
+  suffix?: string;
+  random?: () => number;
+  words?: string[];
+}
+
+export function poutineIpsum(options?: PoutineIpsumFunctionOptions): string;
+
+export default poutineIpsum;

package/src/index.js

@@ -0,0 +1,278 @@
+import os from "node:os";
+import { DICTIONARIES } from "./dictionaries.js";
+
+const DEFAULT_LANGUAGE = "fr";
+const STARTER_TEXT = "Poutine ipsum dolor sit amet";
+const STARTER_WORDS = STARTER_TEXT.split(" ");
+
+const DEFAULT_CLASS_OPTIONS = {
+  language: DEFAULT_LANGUAGE,
+  sentencesPerParagraph: {
+    min: 3,
+    max: 7,
+  },
+  wordsPerSentence: {
+    min: 5,
+    max: 15,
+  },
+  random: Math.random,
+  suffix: os.EOL,
+};
+
+const DEFAULT_FUNCTION_OPTIONS = {
+  count: 1,
+  format: "plain",
+  paragraphLowerBound: 3,
+  paragraphUpperBound: 7,
+  sentenceLowerBound: 5,
+  sentenceUpperBound: 15,
+  suffix: os.EOL,
+  units: "sentences",
+  random: Math.random,
+  language: DEFAULT_LANGUAGE,
+  words: undefined,
+};
+
+function normalizeLanguage(language) {
+  return language === "fr" ? "fr" : "en";
+}
+
+function normalizeVocabulary(vocabulary) {
+  if (vocabulary === "classic" || vocabulary === "extended") {
+    return vocabulary;
+  }
+  return "all";
+}
+
+function getWords(language, customWords, vocabulary) {
+  if (Array.isArray(customWords) && customWords.length > 0) {
+    return customWords;
+  }
+
+  const dict = DICTIONARIES[normalizeLanguage(language)];
+  const v = normalizeVocabulary(vocabulary);
+
+  if (v === "classic") {
+    return dict.classic;
+  }
+  if (v === "extended") {
+    return dict.extended;
+  }
+  return [...dict.classic, ...dict.extended];
+}
+
+function randomInt(min, max, random) {
+  return Math.floor(random() * (max - min + 1)) + min;
+}
+
+function randomWord(words, random, previousWord) {
+  if (words.length === 1) {
+    return words[0];
+  }
+
+  const firstIndex = randomInt(0, words.length - 1, random);
+  let candidate = words[firstIndex];
+
+  if (candidate === previousWord) {
+    const nextIndex = (firstIndex + 1) % words.length;
+    candidate = words[nextIndex];
+  }
+
+  return candidate;
+}
+
+function toSentence(words, random) {
+  if (words.length === 0) {
+    return "";
+  }
+
+  const punct = [".", ".", ".", "!", "?"];
+  const ending = punct[randomInt(0, punct.length - 1, random)];
+
+  const firstWord = words[0];
+  words[0] = firstWord.charAt(0).toUpperCase() + firstWord.slice(1);
+
+  return `${words.join(" ")}${ending}`;
+}
+
+function generateWordArray(count, words, random) {
+  const result = [];
+
+  while (result.length < count) {
+    const previousWord = result[result.length - 1];
+    result.push(randomWord(words, random, previousWord));
+  }
+
+  return result;
+}
+
+function normalizeUnits(units) {
+  const value = String(units).toLowerCase();
+
+  if (value === "word" || value === "words") {
+    return "words";
+  }
+
+  if (value === "paragraph" || value === "paragraphs") {
+    return "paragraphs";
+  }
+
+  return "sentences";
+}
+
+function buildLeadingWords(count, words, random) {
+  const safeCount = Math.max(STARTER_WORDS.length, count);
+  const tailCount = Math.max(0, safeCount - STARTER_WORDS.length);
+  const tailWords = generateWordArray(tailCount, words, random);
+  return [...STARTER_WORDS, ...tailWords];
+}
+
+function createGenerator(config) {
+  return {
+    generateWords(count = 1) {
+      const leadingWords = buildLeadingWords(
+        count,
+        config.words,
+        config.random,
+      );
+      return leadingWords.join(" ");
+    },
+
+    generateSentence(includeStarter = true) {
+      const count = randomInt(
+        config.wordsPerSentence.min,
+        config.wordsPerSentence.max,
+        config.random,
+      );
+
+      if (includeStarter) {
+        return toSentence(
+          buildLeadingWords(count, config.words, config.random),
+          config.random,
+        );
+      }
+
+      return toSentence(
+        generateWordArray(count, config.words, config.random),
+        config.random,
+      );
+    },
+
+    generateSentences(count = 1, includeStarter = true) {
+      const safeCount = Math.max(1, count);
+      const output = [];
+
+      for (let i = 0; i < safeCount; i += 1) {
+        output.push(this.generateSentence(includeStarter && i === 0));
+      }
+
+      return output.join(" ");
+    },
+
+    generateParagraph(includeStarter = true) {
+      const count = randomInt(
+        config.sentencesPerParagraph.min,
+        config.sentencesPerParagraph.max,
+        config.random,
+      );
+
+      return this.generateSentences(count, includeStarter);
+    },
+
+    generateParagraphs(count = 1) {
+      const safeCount = Math.max(1, count);
+      const output = [];
+
+      for (let i = 0; i < safeCount; i += 1) {
+        output.push(this.generateParagraph(i === 0));
+      }
+
+      return output.join(config.suffix);
+    },
+  };
+}
+
+export class PoutineIpsum {
+  constructor(options = {}) {
+    const mergedOptions = {
+      ...DEFAULT_CLASS_OPTIONS,
+      ...options,
+      sentencesPerParagraph: {
+        ...DEFAULT_CLASS_OPTIONS.sentencesPerParagraph,
+        ...(options.sentencesPerParagraph || {}),
+      },
+      wordsPerSentence: {
+        ...DEFAULT_CLASS_OPTIONS.wordsPerSentence,
+        ...(options.wordsPerSentence || {}),
+      },
+    };
+
+    this.options = mergedOptions;
+    this.options.language = normalizeLanguage(mergedOptions.language);
+    this.words = getWords(this.options.language, mergedOptions.words, mergedOptions.vocabulary);
+    this.generator = createGenerator({
+      words: this.words,
+      random: this.options.random,
+      wordsPerSentence: this.options.wordsPerSentence,
+      sentencesPerParagraph: this.options.sentencesPerParagraph,
+      suffix: this.options.suffix,
+    });
+  }
+
+  generateWords(count = 1) {
+    return this.generator.generateWords(count);
+  }
+
+  generateSentences(count = 1) {
+    return this.generator.generateSentences(count);
+  }
+
+  generateParagraphs(count = 1) {
+    return this.generator.generateParagraphs(count);
+  }
+}
+
+export function poutineIpsum(options = {}) {
+  const config = {
+    ...DEFAULT_FUNCTION_OPTIONS,
+    ...options,
+  };
+
+  const words = getWords(config.language, config.words, config.vocabulary);
+  const generator = createGenerator({
+    words,
+    random: config.random,
+    wordsPerSentence: {
+      min: config.sentenceLowerBound,
+      max: config.sentenceUpperBound,
+    },
+    sentencesPerParagraph: {
+      min: config.paragraphLowerBound,
+      max: config.paragraphUpperBound,
+    },
+    suffix: config.suffix,
+  });
+
+  const units = normalizeUnits(config.units);
+
+  if (units === "words") {
+    return generator.generateWords(config.count);
+  }
+
+  if (units === "sentences") {
+    return generator.generateSentences(config.count);
+  }
+
+  const paragraphs = generator.generateParagraphs(config.count);
+
+  if (config.format === "html") {
+    return paragraphs
+      .split(config.suffix)
+      .map((line) => `<p>${line}</p>`)
+      .join(config.suffix);
+  }
+
+  return paragraphs;
+}
+
+export default poutineIpsum;