ipa-core 1.1.1 → 1.1.12

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "ipa-core",
-  "version": "1.1.1",
+  "version": "1.1.12",
   "description": "Language-agnostic IPA core with features",
   "license": "ISC",
   "author": "Cody Bruno",
   "type": "commonjs",
   "bin": {
-    "make-conlang": "./generate-conlang.cjs",
-    "ipa-init": "./generate-config.cjs"
+    "make-conlang": "generate-conlang.js",
+    "ipa-init": "generate-config.js"
   },
   "main": "index.js",
   "scripts": {

package/generate-config.cjs

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-// generate-config-cli.cjs
-
-const fs = require('fs');
-const path = require('path');
-
-const core = require('./core.cjs');       // your ES6 exports can stay; if core.js is ES module, you can require with .default
-const modifiers = require('./modifiers.cjs'); // same as above
-
-// -----------------------------
-// GROUP IPA SYMBOLS BY TYPE
-// -----------------------------
-function groupByType(core) {
-  const groups = {};
-  for (const [symbol, data] of Object.entries(core)) {
-    const type = data.type || 'other';
-    if (!groups[type]) groups[type] = [];
-    groups[type].push(symbol);
-  }
-  return groups;
-}
-
-// -----------------------------
-// WRAP SYMBOL LINES
-// -----------------------------
-function wrapSymbols(symbols, perLine = 12) {
-  const lines = [];
-  for (let i = 0; i < symbols.length; i += perLine) {
-    lines.push('// ' + symbols.slice(i, i + perLine).join(' '));
-  }
-  return lines.join('\n');
-}
-
-// -----------------------------
-// IPA SECTION
-// -----------------------------
-function generateIPASection(core) {
-  const grouped = groupByType(core);
-  const sections = Object.entries(grouped).map(([type, symbols]) => {
-    symbols.sort((a, b) => a.localeCompare(b));
-    return [`// ${type.toUpperCase()}`, wrapSymbols(symbols), ''].join('\n');
-  });
-  return ['/**', ' * IPA SYMBOL REFERENCE', ' * Copy/paste symbols as needed', '', ...sections].join('\n');
-}
-
-// -----------------------------
-// WRAP MODIFIERS HORIZONTALLY
-// -----------------------------
-function wrapModifiers(modList, maxLineLength = 90) {
-  const lines = [];
-  let currentLine = '// ';
-  modList.forEach((mod, index) => {
-    const separator = index === 0 ? '' : ' | ';
-    const nextChunk = separator + mod;
-    if ((currentLine + nextChunk).length > maxLineLength) {
-      lines.push(currentLine);
-      currentLine = '// ' + mod;
-    } else {
-      currentLine += nextChunk;
-    }
-  });
-  if (currentLine.trim()) lines.push(currentLine);
-  return lines.join('\n');
-}
-
-// -----------------------------
-// MODIFIER SECTION
-// -----------------------------
-function generateModifierSection(modifiers) {
-  const entries = Object.entries(modifiers);
-  entries.sort(([a], [b]) => a.localeCompare(b));
-  const formatted = entries.map(([key, data]) => {
-    const appliesTo = Array.isArray(data.appliesTo) ? data.appliesTo.join(', ') : data.appliesTo || '';
-    return `${key}(${appliesTo})`;
-  });
-  return ['/**', ' * MODIFIER REFERENCE', ' * modifier(appliesTo)', ' */', '', wrapModifiers(formatted), ''].join('\n');
-}
-
-// -----------------------------
-// ORTHOGRAPHY EXPORT SECTION
-// -----------------------------
-function generateOrthographyExport() {
-  const commentedOrthography = [
-    '// k: ["k", ["aspirated"]],',
-    '// a: ["ɑ", ["more_rounded"]],',
-    '// x̱: [',
-    '//   ["k", ["ejective", "aspirated"]],',
-    '//   ["x", []]',
-    '// ],',
-    '// l: ["ɬ"]'
-  ].join('\n');
-
-  return [
-    '/**',
-    ' * ORTHOGRAPHY CONFIG',
-    ' * Use parseConfig() at runtime',
-    ' *',
-    ' * Fill in your orthography below; examples are commented out.',
-    ' */',
-    '',
-    "const { parseConfig } = require('./parser.cjs');",
-    '',
-    'const orthography = {',
-    commentedOrthography,
-    '};',
-    '',
-    'module.exports = parseConfig(orthography);',
-    ''
-  ].join('\n');
-}
-
-// -----------------------------
-// MAIN GENERATOR
-// -----------------------------
-function generateConfig() {
-  const content = [
-    generateIPASection(core),
-    '',
-    generateModifierSection(modifiers),
-    '',
-    generateOrthographyExport()
-  ].join('\n');
-
-  const outputPath = path.join(process.cwd(), 'ipa.config.js');
-  fs.writeFileSync(outputPath, content, 'utf-8');
-
-  console.log('✅ ipa.config.js generated with parseConfig() export');
-}
-
-// RUN
-generateConfig();

package/generate-conlang.cjs

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-// generate-conlang-cli.cjs
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-const core = require('./core.cjs');       // Use .default if core.js is ES module
-const modifiers = require('./modifiers.cjs'); // Use .default if modifiers.js is ES module
-
-/** Pick random element */
-const pickRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
-
-/** Shuffle array */
-const shuffle = (arr) => {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-  return arr;
-};
-
-/** Prompt helper */
-function prompt(query) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  return new Promise((resolve) =>
-    rl.question(query, (ans) => {
-      rl.close();
-      resolve(ans);
-    })
-  );
-}
-
-/** Generate conlang orthography */
-function generateConlang({ alphabet, mod1Chance, mod2Chance, affricateChance }) {
-  const letters = alphabet.split('');
-  const usedIPA = new Set();
-  const orthography = {};
-  const coreKeys = shuffle(Object.keys(core));
-
-  letters.forEach((letter) => {
-    // Pick unused IPA
-    let ipaKey;
-    while (true) {
-      const candidate = pickRandom(coreKeys);
-      if (!usedIPA.has(candidate)) {
-        ipaKey = candidate;
-        usedIPA.add(candidate);
-        break;
-      }
-    }
-
-    const baseObj = core[ipaKey];
-    const modifiersList = [];
-
-    // Modifier 1
-    if (Math.random() < mod1Chance) {
-      const compatible = Object.entries(modifiers).filter(
-        ([, mod]) => !mod.appliesTo || mod.appliesTo.includes(baseObj?.type)
-      );
-      if (compatible.length) modifiersList.push(pickRandom(compatible)[0]);
-    }
-
-    // Modifier 2
-    if (Math.random() < mod2Chance && modifiersList.length) {
-      const compatible = Object.entries(modifiers).filter(
-        ([key, mod]) =>
-          !modifiersList.includes(key) &&
-          (!mod.appliesTo || mod.appliesTo.includes(baseObj?.type))
-      );
-      if (compatible.length) modifiersList.push(pickRandom(compatible)[0]);
-    }
-
-    // Plosive → affricate
-    if (baseObj?.features?.manner === 'plosive' && Math.random() < affricateChance) {
-      const fricatives = Object.entries(core).filter(
-        ([, obj]) =>
-          obj?.features?.manner === 'fricative' &&
-          obj.features.place === baseObj.features.place
-      );
-      if (fricatives.length) {
-        const fricKey = pickRandom(fricatives)[0];
-        orthography[letter] = [
-          [ipaKey, modifiersList],
-          [fricKey, []],
-        ];
-        return;
-      }
-    }
-
-    orthography[letter] = [ipaKey, modifiersList];
-  });
-
-  return orthography;
-}
-
-/** Main async function */
-async function main() {
-  const alphabet = (await prompt('Enter alphabet (default a-z): ')) || 'abcdefghijklmnopqrstuvwxyz';
-  const mod1 = parseFloat((await prompt('Modifier 1 chance (default 0.33): ')) || '0.33');
-  const mod2 = parseFloat((await prompt('Modifier 2 chance (default 0.06): ')) || '0.06');
-  const aff = parseFloat((await prompt('Plosive → affricate chance (default 0.1): ')) || '0.1');
-
-  const orthography = generateConlang({
-    alphabet,
-    mod1Chance: mod1,
-    mod2Chance: mod2,
-    affricateChance: aff,
-  });
-
-  const outPath = path.join(process.cwd(), 'generatedConlang.js');
-  const lines = Object.entries(orthography).map(
-    ([l, v]) => `  ${JSON.stringify(l)}:${JSON.stringify(v)}`
-  );
-
-  const content = `/** Generated conlang orthography */\nconst generatedOrthography = {\n${lines.join(',\n')}\n};\nmodule.exports = generatedOrthography;\n`;
-
-  fs.writeFileSync(outPath, content, 'utf-8');
-  console.log('✅ generatedConlang.js written');
-}
-
-main();