@litlab/audx 0.6.0 → 0.8.5

package/dist/bin.js

@@ -1,10 +1,9 @@
-#!/usr/bin/env node
 import * as p from '@clack/prompts';
+import { a as _object_without_properties_loose, _ as _extends } from './cc-zJdVkWBV.js';
 import { existsSync, mkdirSync } from 'node:fs';
 import { readdir, readFile, writeFile, unlink } from 'node:fs/promises';
 import __node_cjsPath, { resolve, join, basename, isAbsolute } from 'node:path';
 import pc from 'picocolors';
-import { _ as _object_without_properties_loose } from './cc-DgCkkqq8.js';
 import __node_cjsModule from 'node:module';
 import __node_cjsUrl from 'node:url';
 
@@ -386,6 +385,10 @@ function parseAddOptions(args) {
             options.list = true;
         } else if (arg === "--theme") {
             options.theme = args[++i];
+        } else if (arg === "--data") {
+            options.data = args[++i];
+        } else if (arg === "--tune") {
+            options.tune = args[++i];
         } else if (arg && !arg.startsWith("-")) {
             source = arg;
         }
@@ -399,9 +402,21 @@ async function add(args) {
     const { source, options } = parseAddOptions(args);
     p.intro("@litlab/audx add");
     if (!source) {
+        if (options.data || options.tune) {
+            p.log.error("--data and --tune require a sound name.");
+            process.exit(1);
+        }
         await addFromRegistry(options);
         return;
     }
+    if (options.data) {
+        await addEncodedSound(source, options);
+        return;
+    }
+    if (options.tune) {
+        await addTunedSound(source, options);
+        return;
+    }
     if (isLocalSource(source)) {
         await addFromLocal(source, options);
         return;
@@ -416,6 +431,178 @@ async function add(args) {
     }
     await addSoundFromRegistry(source, options);
 }
+const WAVEFORM_CODES = {
+    o: "original",
+    s: "sine",
+    t: "triangle",
+    q: "square",
+    w: "sawtooth"
+};
+function decodeSoundCustomization(value) {
+    const [version, pitch, duration, gain, pan, waveform, ...extra] = value.split(".");
+    if (version !== "1" || extra.length > 0 || !pitch || !duration || !gain || !pan || !waveform) {
+        throw new Error("unsupported tuning token");
+    }
+    const settings = {
+        pitch: Number.parseInt(pitch, 36) - 12,
+        duration: Number.parseInt(duration, 36) / 20,
+        gain: Number.parseInt(gain, 36) / 20,
+        pan: (Number.parseInt(pan, 36) - 20) / 20,
+        waveform: WAVEFORM_CODES[waveform]
+    };
+    if (!Number.isInteger(settings.pitch) || settings.pitch < -12 || settings.pitch > 12 || !Number.isFinite(settings.duration) || settings.duration < 0.25 || settings.duration > 3 || !Number.isFinite(settings.gain) || settings.gain < 0 || settings.gain > 2 || !Number.isFinite(settings.pan) || settings.pan < -1 || settings.pan > 1 || !settings.waveform) {
+        throw new Error("invalid tuning values");
+    }
+    return settings;
+}
+async function addTunedSound(soundName, options) {
+    if (!options.theme) {
+        p.log.error("--tune requires --theme <name>.");
+        process.exit(1);
+    }
+    let settings;
+    try {
+        var _options_tune;
+        settings = decodeSoundCustomization((_options_tune = options.tune) != null ? _options_tune : "");
+    } catch (err) {
+        p.log.error(`Invalid tuning token: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start(`Fetching "${soundName}" from ${options.theme}...`);
+    try {
+        const theme = await fetchThemeJson(options.theme);
+        if (!validateTheme(theme)) throw new Error("invalid theme");
+        const match = Object.entries(theme.sounds).find(([name])=>name.toLowerCase() === soundName.toLowerCase());
+        if (!match) throw new Error(`sound not found in theme "${options.theme}"`);
+        const definition = customizeDefinition(match[1], settings);
+        if (!validateSoundDefinition(definition)) {
+            throw new Error("theme returned an invalid sound definition");
+        }
+        s.stop(`Customized "${soundName}" from ${theme.name}`);
+        await writeSound(soundName, definition, options);
+        p.note(`  - ${soundName}`, "Installed customized sound");
+        p.outro("Done!");
+    } catch (err) {
+        s.stop("Failed to install customized sound.");
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+function customizeDefinition(value, settings) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const definition = value;
+    if (Array.isArray(definition.layers)) {
+        return _extends({}, definition, {
+            layers: definition.layers.map((layer)=>customizeDefinition(layer, settings)),
+            effects: scaleEffects(definition.effects, settings.duration)
+        });
+    }
+    const source = customizeSource(definition.source, settings);
+    const envelope = definition.envelope && typeof definition.envelope === "object" && !Array.isArray(definition.envelope) ? scaleEnvelope(definition.envelope, settings.duration) : undefined;
+    const gain = typeof definition.gain === "number" ? definition.gain : 0.5;
+    const delay = typeof definition.delay === "number" ? definition.delay : 0;
+    return _extends({}, definition, {
+        source,
+        envelope,
+        gain: clamp(gain * settings.gain, 0, 1)
+    }, "panner" in definition ? {} : {
+        pan: clamp((typeof definition.pan === "number" ? definition.pan : 0) + settings.pan, -1, 1)
+    }, {
+        delay: delay * settings.duration,
+        effects: scaleEffects(definition.effects, settings.duration)
+    });
+}
+function customizeSource(value, settings) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const source = value;
+    const frequencyScale = 2 ** (settings.pitch / 12);
+    if (source.type === "sine" || source.type === "triangle" || source.type === "square" || source.type === "sawtooth" || source.type === "wavetable") {
+        return _extends({}, source, source.type === "wavetable" || settings.waveform === "original" ? {} : {
+            type: settings.waveform
+        }, {
+            frequency: scaleFrequency(source.frequency, frequencyScale)
+        });
+    }
+    if (source.type === "sample") {
+        return _extends({}, source, {
+            detune: (typeof source.detune === "number" ? source.detune : 0) + settings.pitch * 100
+        });
+    }
+    return source;
+}
+function scaleFrequency(value, scale) {
+    if (typeof value === "number") return value * scale;
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const frequency = value;
+    if (typeof frequency.start !== "number" || typeof frequency.end !== "number") {
+        return value;
+    }
+    return {
+        start: frequency.start * scale,
+        end: frequency.end * scale
+    };
+}
+function scaleEnvelope(envelope, duration) {
+    return _extends({}, envelope, {
+        attack: (typeof envelope.attack === "number" ? envelope.attack : 0) * duration,
+        decay: (typeof envelope.decay === "number" ? envelope.decay : 0) * duration,
+        release: (typeof envelope.release === "number" ? envelope.release : 0) * duration
+    });
+}
+function scaleEffects(value, duration) {
+    if (!Array.isArray(value)) return undefined;
+    return value.map((effect)=>{
+        if (!effect || typeof effect !== "object" || Array.isArray(effect)) {
+            return effect;
+        }
+        const item = effect;
+        if (item.type === "delay") {
+            return _extends({}, item, {
+                time: (typeof item.time === "number" ? item.time : 0.25) * duration
+            });
+        }
+        if (item.type === "reverb") {
+            return _extends({}, item, {
+                decay: (typeof item.decay === "number" ? item.decay : 0.5) * duration,
+                preDelay: (typeof item.preDelay === "number" ? item.preDelay : 0) * duration
+            });
+        }
+        return item;
+    });
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+async function addEncodedSound(soundName, options) {
+    let definition;
+    try {
+        var _options_data;
+        definition = decodeSoundDefinition((_options_data = options.data) != null ? _options_data : "");
+    } catch (err) {
+        p.log.error(`Invalid customized sound data: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    if (!validateSoundDefinition(definition)) {
+        p.log.error("Invalid customized sound definition.");
+        process.exit(1);
+    }
+    await writeSound(soundName, definition, options);
+    p.note(`  - ${soundName}`, "Installed customized sound");
+    p.outro("Done!");
+}
+function decodeSoundDefinition(value) {
+    if (!value) throw new Error("missing value");
+    return JSON.parse(Buffer.from(value, "base64url").toString("utf-8"));
+}
+function validateSoundDefinition(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const definition = value;
+    if (Array.isArray(definition.layers)) {
+        return definition.layers.length > 0 && definition.layers.every(validateSoundDefinition);
+    }
+    return !!definition.source && typeof definition.source === "object" && !Array.isArray(definition.source);
+}
 async function addFromLocal(source, options) {
     const s = p.spinner();
     s.start("Scanning local path for themes...");
@@ -1147,6 +1334,8 @@ function showHelp() {
         "  -l, --list      Preview available themes without installing",
         "  -y, --yes       Skip confirmation prompts",
         "  --theme <name>  Install a specific theme by name",
+        "  --data <value>  Install an encoded customized sound definition",
+        "  --tune <token>  Apply compact editor settings (requires --theme)",
         "",
         "Remove Options:",
         "  -y, --yes       Skip confirmation prompts"

package/dist/{cc-DgCkkqq8.js → cc-zJdVkWBV.js}

@@ -1,3 +1,14 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
 function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
     var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
@@ -10,4 +21,4 @@ function _object_without_properties_loose(source, excluded) {
     return target;
 }
 
-export { _object_without_properties_loose as _ };
+export { _extends as _, _object_without_properties_loose as a };

package/dist/index.js

@@ -1293,7 +1293,9 @@ function createPatchInstance(data) {
  * @throws {Error} If the network request fails
  */ async function loadPatch(source) {
     if (typeof source === "string") {
-        const response = await fetch(source);
+        const response = await fetch(source, {
+            cache: "no-store"
+        });
         if (!response.ok) throw new Error(`Failed to load patch from ${source}: ${response.status}`);
         const data = await response.json();
         return createPatchInstance(data);

package/dist/react.js

@@ -1149,7 +1149,9 @@ function createPatchInstance(data) {
  * @throws {Error} If the network request fails
  */ async function loadPatch(source) {
     if (typeof source === "string") {
-        const response = await fetch(source);
+        const response = await fetch(source, {
+            cache: "no-store"
+        });
         if (!response.ok) throw new Error(`Failed to load patch from ${source}: ${response.status}`);
         const data = await response.json();
         return createPatchInstance(data);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@litlab/audx",
-	"version": "0.6.0",
+	"version": "0.8.5",
 	"description": "Core Engine For Semantic Web Audio",
 	"author": "Om Mishra",
 	"license": "MIT",