node-av 1.0.3 → 1.2.0

package/dist/lib/dictionary.js

@@ -1,127 +1,75 @@
+import { AVFLAG_NONE } from '../constants/constants.js';
 import { bindings } from './binding.js';
-import { AVFLAG_NONE } from './constants.js';
 /**
- * Dictionary for options and metadata.
+ * Key-value dictionary for FFmpeg options and metadata.
  *
- * Key-value storage for codec options, format options, and metadata.
- * Used throughout FFmpeg for configuration and information storage.
- * Supports parsing from strings and conversion back to strings.
+ * Stores string key-value pairs used throughout FFmpeg for options, metadata,
+ * and configuration. Provides methods for setting, getting, and manipulating
+ * dictionary entries. Used extensively for codec options, format options,
+ * and metadata handling.
  *
  * Direct mapping to FFmpeg's AVDictionary.
  *
  * @example
  * ```typescript
- * import { Dictionary, CodecContext, FFmpegError } from 'node-av';
- *
- * // Using Dictionary for codec options
- * const options = new Dictionary();
- * const ret1 = options.set('preset', 'fast', 0);
- * FFmpegError.throwIfError(ret1, 'set preset');
- * const ret2 = options.set('crf', '23', 0);
- * FFmpegError.throwIfError(ret2, 'set crf');
- *
- * const codecContext = new CodecContext();
- * codecContext.allocContext3(codec);
- * const openRet = await codecContext.open2(codec, options);
- * FFmpegError.throwIfError(openRet, 'open2');
- *
- * // Using Dictionary for format options
- * const formatOptions = new Dictionary();
- * const ret3 = formatOptions.set('movflags', 'faststart', 0);
- * FFmpegError.throwIfError(ret3, 'set movflags');
- * const headerRet = await formatContext.writeHeader(formatOptions);
- * FFmpegError.throwIfError(headerRet, 'writeHeader');
- *
- * // Reading metadata
- * const metadata = stream.metadata;
- * if (metadata) {
- *   const title = metadata.get('title', 0);
- *   const artist = metadata.get('artist', 0);
- *   console.log(`Title: ${title}, Artist: ${artist}`);
- * }
- *
- * // Cleanup
- * options.free();
- * formatOptions.free();
- * ```
- *
- * @example
- * ```typescript
  * import { Dictionary, FFmpegError } from 'node-av';
+ * import { AV_DICT_IGNORE_SUFFIX } from 'node-av/constants';
  *
- * // Parsing options from string
- * const dict = new Dictionary();
- * const ret = dict.parseString('bitrate=128k:preset=fast', '=', ':', 0);
- * FFmpegError.throwIfError(ret, 'parseString');
+ * // Create from object
+ * const dict = Dictionary.fromObject({
+ *   'title': 'My Video',
+ *   'artist': 'Me',
+ *   'year': '2024'
+ * });
  *
- * // Getting all options as object
- * const allOptions = dict.getAll();
- * console.log(allOptions); // { bitrate: '128k', preset: 'fast' }
+ * // Set individual values
+ * const dict2 = new Dictionary();
+ * dict2.alloc();
+ * let ret = dict2.set('preset', 'fast');
+ * FFmpegError.throwIfError(ret, 'set');
  *
- * // Converting back to string
- * const str = dict.getString('=', ':');
- * console.log(str); // "bitrate=128k:preset=fast"
+ * // Parse from string
+ * ret = dict2.parseString('key1=value1:key2=value2', '=', ':');
+ * FFmpegError.throwIfError(ret, 'parseString');
  *
- * dict.free();
+ * // Get all entries
+ * const entries = dict2.getAll();
+ * console.log(entries); // { key1: 'value1', key2: 'value2' }
  * ```
+ *
+ * @see [AVDictionary](https://ffmpeg.org/doxygen/trunk/group__lavu__dict.html) - FFmpeg Doxygen
+ * @see {@link CodecContext} For codec options
+ * @see {@link FormatContext} For format options
  */
 export class Dictionary {
     native;
-    /**
-     * Create a new dictionary.
-     *
-     * The dictionary is uninitialized and will be auto-allocated on first set() call.
-     * No FFmpeg resources are allocated until first use.
-     *
-     * Direct wrapper around AVDictionary.
-     *
-     * @example
-     * ```typescript
-     * import { Dictionary, FFmpegError } from 'node-av';
-     *
-     * const dict = new Dictionary();
-     * const ret = dict.set('key', 'value', 0); // Auto-allocates on first use
-     * FFmpegError.throwIfError(ret, 'set');
-     * ```
-     */
     constructor() {
         this.native = new bindings.Dictionary();
     }
     /**
-     * Create a Dictionary wrapper from an existing native dictionary.
-     * Used internally when wrapping dictionaries from FFmpeg.
-     * @internal
-     */
-    static fromNative(native) {
-        const dict = Object.create(Dictionary.prototype);
-        dict.native = native;
-        return dict;
-    }
-    /**
-     * Create a Dictionary from a JavaScript object.
+     * Create dictionary from JavaScript object.
      *
-     * Converts a plain JavaScript object to a Dictionary.
-     * Useful for converting option objects to FFmpeg format.
+     * Convenience method to create a dictionary from a plain object.
      *
      * @param obj - Object with string key-value pairs
-     * @param flags - AV_DICT_* flags for set operations
-     *
-     * @returns New Dictionary containing all entries from the object
+     * @param flags - Flags for setting entries
+     * @returns New dictionary with entries from object
      *
      * @example
      * ```typescript
-     * import { Dictionary } from 'node-av';
-     *
-     * const options = {
-     *   bitrate: '128k',
-     *   preset: 'fast',
-     *   crf: '23'
-     * };
-     *
-     * const dict = Dictionary.fromObject(options);
-     * // Use with codec or format context
-     * await codecContext.open2(codec, dict);
-     * dict.free();
+     * const metadata = Dictionary.fromObject({
+     *   'title': 'My Song',
+     *   'album': 'My Album',
+     *   'date': '2024',
+     *   'track': '1/10'
+     * });
+     *
+     * // Use for codec options
+     * const options = Dictionary.fromObject({
+     *   'preset': 'medium',
+     *   'crf': '23',
+     *   'profile': 'high'
+     * });
      * ```
      */
     static fromObject(obj, flags = AVFLAG_NONE) {
@@ -132,123 +80,127 @@ export class Dictionary {
         return dict;
     }
     /**
-     * Allocate a new dictionary.
+     * Create dictionary from native instance.
      *
-     * Usually not needed as set() will auto-allocate.
-     * This is mainly for compatibility - FFmpeg doesn't have explicit av_dict_alloc.
+     * @param native - Native dictionary instance
+     * @returns Dictionary wrapper
+     *
+     * @internal
+     */
+    static fromNative(native) {
+        const dict = Object.create(Dictionary.prototype);
+        dict.native = native;
+        return dict;
+    }
+    /**
+     * Allocate a dictionary.
+     *
+     * Allocates memory for the dictionary structure.
+     * Must be called before using the dictionary.
+     *
+     * Direct mapping to av_dict_alloc().
+     *
+     * @throws {Error} If allocation fails (ENOMEM)
      *
      * @example
      * ```typescript
      * const dict = new Dictionary();
-     * dict.alloc(); // Explicit allocation (optional)
+     * dict.alloc();
+     * // Dictionary is now ready for use
      * ```
+     *
+     * @see {@link free} To deallocate
      */
     alloc() {
-        return this.native.alloc();
+        this.native.alloc();
     }
     /**
-     * Free all the memory allocated for an AVDictionary struct and all keys and values.
+     * Free the dictionary.
+     *
+     * Releases all memory associated with the dictionary.
+     * The dictionary becomes invalid after calling this.
      *
-     * Direct mapping to av_dict_free()
-     * After calling this, the dictionary is empty and can be reused.
+     * Direct mapping to av_dict_free().
      *
      * @example
      * ```typescript
      * dict.free();
-     * // Dictionary is now empty and can be reused
-     * dict.set('new_key', 'new_value', 0);
+     * // Dictionary is now invalid
      * ```
+     *
+     * @see {@link alloc} To allocate
+     * @see {@link Symbol.dispose} For automatic cleanup
      */
     free() {
-        return this.native.free();
+        this.native.free();
     }
     /**
-     * Copy entries from this dictionary to destination.
-     *
-     * Copies all entries to the destination dictionary.
-     * Destination entries can be preserved or overwritten based on flags.
+     * Copy entries to another dictionary.
      *
-     * Direct mapping to av_dict_copy()
+     * Copies all entries from this dictionary to the destination.
      *
-     * @param dst - Target dictionary to copy to
-     * @param flags - AV_DICT_* flags for the copy operation
+     * Direct mapping to av_dict_copy().
      *
+     * @param dst - Destination dictionary
+     * @param flags - Copy flags
      * @returns 0 on success, negative AVERROR on error:
-     *   - 0: Success
-     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - AVERROR_ENOMEM: Memory allocation failure
      *
      * @example
      * ```typescript
-     * import { Dictionary, FFmpegError } from 'node-av';
-     *
-     * const src = new Dictionary();
-     * src.set('key1', 'value1');
-     * src.set('key2', 'value2');
+     * import { FFmpegError } from 'node-av';
      *
      * const dst = new Dictionary();
+     * dst.alloc();
      * const ret = src.copy(dst);
      * FFmpegError.throwIfError(ret, 'copy');
      * ```
-     *
-     * @note Common flags:
-     * - AVFLAG_NONE: Default behavior
-     * - AV_DICT_DONT_OVERWRITE: Don't overwrite existing entries
-     * - AV_DICT_MULTIKEY: Allow multiple entries with same key
      */
     copy(dst, flags = AVFLAG_NONE) {
         return this.native.copy(dst.getNative(), flags);
     }
     /**
-     * Set the given entry in the dictionary.
+     * Set a dictionary entry.
      *
-     * Adds or modifies a key-value pair in the dictionary.
-     * If key or value are empty, the entry is deleted.
-     * The dictionary will be auto-allocated on first call if needed.
+     * Sets or updates a key-value pair in the dictionary.
      *
-     * Direct mapping to av_dict_set()
-     *
-     * @param key - Entry key to add/modify
-     * @param value - Entry value to add/modify
-     * @param flags - AV_DICT_* flags
+     * Direct mapping to av_dict_set().
      *
+     * @param key - Entry key
+     * @param value - Entry value
+     * @param flags - Set flags (e.g., AV_DICT_DONT_OVERWRITE)
      * @returns 0 on success, negative AVERROR on error:
-     *   - 0: Success
-     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - AVERROR_ENOMEM: Memory allocation failure
      *
      * @example
      * ```typescript
-     * import { Dictionary, FFmpegError } from 'node-av';
+     * import { FFmpegError } from 'node-av';
      * import { AV_DICT_DONT_OVERWRITE } from 'node-av/constants';
      *
-     * const ret1 = dict.set('bitrate', '128k');
-     * FFmpegError.throwIfError(ret1, 'set bitrate');
-     *
-     * const ret2 = dict.set('preset', 'fast', AV_DICT_DONT_OVERWRITE);
-     * FFmpegError.throwIfError(ret2, 'set preset');
+     * // Set or update entry
+     * let ret = dict.set('bitrate', '128k');
+     * FFmpegError.throwIfError(ret, 'set');
      *
-     * // Delete an entry
-     * dict.set('bitrate', '');
+     * // Set only if not exists
+     * ret = dict.set('preset', 'fast', AV_DICT_DONT_OVERWRITE);
+     * FFmpegError.throwIfError(ret, 'set');
      * ```
      *
-     * @note Common flags:
-     * - AVFLAG_NONE: Default behavior (replace existing, copy strings)
-     * - AV_DICT_DONT_OVERWRITE: Don't overwrite existing entries
-     * - AV_DICT_APPEND: Append to existing value (with comma separator)
-     * - AV_DICT_MULTIKEY: Allow multiple entries with same key
-     * - AV_DICT_MATCH_CASE: Case sensitive key matching
+     * @see {@link get} To retrieve values
      */
     set(key, value, flags = AVFLAG_NONE) {
         return this.native.set(key, value, flags);
     }
     /**
-     * Get a dictionary entry with matching key.
+     * Get a dictionary entry.
      *
-     * Direct mapping to av_dict_get()
+     * Retrieves the value for a given key.
      *
-     * @param key - Key to search for
-     * @param flags - AV_DICT_* flags for matching
+     * Direct mapping to av_dict_get().
      *
-     * @returns Entry value or null if not found
+     * @param key - Entry key to look up
+     * @param flags - Search flags (e.g., AV_DICT_IGNORE_SUFFIX)
+     * @returns Entry value, or null if not found
      *
      * @example
      * ```typescript
@@ -257,22 +209,23 @@ export class Dictionary {
      *   console.log(`Bitrate: ${value}`);
      * }
      *
-     * // Case sensitive search
+     * // Case-insensitive search
+     * import { AV_DICT_MATCH_CASE } from 'node-av/constants';
      * const title = dict.get('Title', AV_DICT_MATCH_CASE);
      * ```
      *
-     * Common flags:
-     * - AVFLAG_NONE: Default (case insensitive)
-     * - AV_DICT_MATCH_CASE: Case sensitive matching
-     * - AV_DICT_IGNORE_SUFFIX: Match entries starting with key
+     * @see {@link set} To set values
+     * @see {@link getAll} To get all entries
      */
     get(key, flags = AVFLAG_NONE) {
         return this.native.get(key, flags);
     }
     /**
-     * Get number of entries in dictionary.
+     * Count dictionary entries.
      *
-     * Direct mapping to av_dict_count()
+     * Returns the number of key-value pairs in the dictionary.
+     *
+     * Direct mapping to av_dict_count().
      *
      * @returns Number of entries
      *
@@ -286,95 +239,92 @@ export class Dictionary {
         return this.native.count();
     }
     /**
-     * Get all entries as a JavaScript object.
+     * Get all dictionary entries.
      *
-     * Helper method for easier access from JavaScript.
-     * Internally iterates through all entries using av_dict_get().
+     * Returns all key-value pairs as a JavaScript object.
      *
-     * @returns Object with all key-value pairs
+     * @returns Object with all entries
      *
      * @example
      * ```typescript
-     * const allOptions = dict.getAll();
-     * for (const [key, value] of Object.entries(allOptions)) {
+     * const entries = dict.getAll();
+     * for (const [key, value] of Object.entries(entries)) {
      *   console.log(`${key}: ${value}`);
      * }
-     *
-     * // Check if dictionary is empty
-     * if (Object.keys(dict.getAll()).length === 0) {
-     *   console.log('Dictionary is empty');
-     * }
      * ```
+     *
+     * @see {@link get} To get individual entries
      */
     getAll() {
         return this.native.getAll();
     }
     /**
-     * Parse the key/value pairs from a string.
+     * Parse entries from a string.
      *
-     * Parses a formatted string into key-value pairs.
-     * Supports both single and multi-character separators.
+     * Parses key-value pairs from a formatted string and adds them
+     * to the dictionary.
      *
-     * Direct mapping to av_dict_parse_string()
-     *
-     * @param str - String to parse (e.g., "key1=value1:key2=value2")
-     * @param keyValSep - String separator between key and value (e.g., '=' or ':=')
-     * @param pairsSep - String separator between pairs (e.g., ':' or ',' or ';')
-     * @param flags - AV_DICT_* flags (default: AVFLAG_NONE)
+     * Direct mapping to av_dict_parse_string().
      *
+     * @param str - String to parse
+     * @param keyValSep - Separator between key and value
+     * @param pairsSep - Separator between pairs
+     * @param flags - Parse flags
      * @returns 0 on success, negative AVERROR on error:
-     *   - 0: Success
-     *   - AVERROR(EINVAL): Invalid parameters
-     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - AVERROR_EINVAL: Invalid format
+     *   - AVERROR_ENOMEM: Memory allocation failure
      *
      * @example
      * ```typescript
-     * import { Dictionary, FFmpegError } from 'node-av';
+     * import { FFmpegError } from 'node-av';
      *
-     * // Parse codec options with single-char separators
-     * const ret = dict.parseString('bitrate=128k:preset=fast', '=', ':');
+     * // Parse colon-separated pairs
+     * let ret = dict.parseString('key1=val1:key2=val2', '=', ':');
      * FFmpegError.throwIfError(ret, 'parseString');
      *
-     * // Parse with multi-char separators
-     * const ret2 = dict.parseString('title:=My Video;;artist:=Me', ':=', ';;');
-     * FFmpegError.throwIfError(ret2, 'parseString');
+     * // Parse comma-separated pairs
+     * ret = dict.parseString('width=1920,height=1080', '=', ',');
+     * FFmpegError.throwIfError(ret, 'parseString');
      * ```
      *
-     * @see {@link getString} To convert back to string
+     * @see {@link getString} To serialize to string
      */
     parseString(str, keyValSep, pairsSep, flags = AVFLAG_NONE) {
         return this.native.parseString(str, keyValSep, pairsSep, flags);
     }
     /**
-     * Get dictionary as a string.
+     * Convert dictionary to string.
      *
-     * Direct mapping to av_dict_get_string()
+     * Serializes all entries to a formatted string.
      *
-     * @param keyValSep - Character to separate key from value
-     * @param pairsSep - Character to separate pairs
+     * Direct mapping to av_dict_get_string().
      *
-     * @returns String representation or null on error
+     * @param keyValSep - Separator between key and value
+     * @param pairsSep - Separator between pairs
+     * @returns Formatted string, or null on error
      *
      * @example
      * ```typescript
+     * // Serialize to colon-separated format
      * const str = dict.getString('=', ':');
-     * console.log(str); // "key1=value1:key2=value2"
+     * console.log(str); // "key1=val1:key2=val2"
      *
-     * // Export as comma-separated
+     * // Serialize to comma-separated format
      * const csv = dict.getString('=', ',');
-     * console.log(csv); // "key1=value1,key2=value2"
+     * console.log(csv); // "key1=val1,key2=val2"
      * ```
      *
-     * @see parseString() - To parse a string back to dictionary
+     * @see {@link parseString} To parse from string
      */
     getString(keyValSep, pairsSep) {
         return this.native.getString(keyValSep, pairsSep);
     }
     /**
-     * Get the native FFmpeg AVDictionary pointer.
+     * Get the underlying native Dictionary object.
      *
-     * @internal For use by other wrapper classes
-     * @returns The underlying native dictionary object
+     * @returns The native Dictionary binding object
+     *
+     * @internal
      */
     getNative() {
         return this.native;
@@ -387,17 +337,13 @@ export class Dictionary {
      *
      * @example
      * ```typescript
-     * import { Dictionary, FFmpegError } from 'node-av';
-     *
      * {
      *   using dict = new Dictionary();
-     *   const ret = dict.set('key', 'value', 0);
-     *   FFmpegError.throwIfError(ret, 'set');
-     *   // ... use dictionary
+     *   dict.alloc();
+     *   dict.set('key', 'value');
+     *   // Use dict...
      * } // Automatically freed when leaving scope
      * ```
-     *
-     * @see {@link free} For manual cleanup
      */
     [Symbol.dispose]() {
         this.native[Symbol.dispose]();

package/dist/lib/dictionary.js.map

@@ -1 +1 @@
-{"version":3,"file":"dictionary.js","sourceRoot":"","sources":["../../src/lib/dictionary.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dictionary.js","sourceRoot":"","sources":["../../src/lib/dictionary.ts"],"names":[],"mappings":"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"}