@hyperfrontend/versioning 0.1.0

package/git/models/index.cjs.js

@@ -0,0 +1,755 @@
+'use strict';
+
+/**
+ * Creates a git commit model.
+ *
+ * @param options - Commit creation options
+ * @returns A new GitCommit object
+ *
+ * @example
+ * const commit = createGitCommit({
+ *   hash: 'abc123...',
+ *   authorName: 'John Doe',
+ *   authorEmail: 'john@example.com',
+ *   authorDate: '2026-03-12T10:00:00Z',
+ *   subject: 'feat: add new feature',
+ * })
+ */
+function createGitCommit(options) {
+    const body = options.body ?? '';
+    const subject = options.subject;
+    return {
+        hash: options.hash,
+        shortHash: getShortHash(options.hash),
+        authorName: options.authorName,
+        authorEmail: options.authorEmail,
+        authorDate: options.authorDate,
+        committerName: options.committerName ?? options.authorName,
+        committerEmail: options.committerEmail ?? options.authorEmail,
+        commitDate: options.commitDate ?? options.authorDate,
+        subject,
+        body,
+        message: body ? `${subject}\n\n${body}` : subject,
+        parents: options.parents ?? [],
+        refs: options.refs ?? [],
+    };
+}
+/**
+ * Gets a short hash (7 characters) from a full commit hash.
+ *
+ * @param hash - Full commit hash
+ * @returns Short hash (7 characters)
+ */
+function getShortHash(hash) {
+    return hash.slice(0, 7);
+}
+/**
+ * Checks if two commits are the same based on their hash.
+ *
+ * @param a - First commit
+ * @param b - Second commit
+ * @returns True if commits have the same hash
+ */
+function isSameCommit(a, b) {
+    return a.hash === b.hash;
+}
+/**
+ * Checks if a commit is a merge commit (has multiple parents).
+ *
+ * @param commit - Commit to check
+ * @returns True if commit has more than one parent
+ */
+function isMergeCommit(commit) {
+    return commit.parents.length > 1;
+}
+/**
+ * Checks if a commit is a root commit (has no parents).
+ *
+ * @param commit - Commit to check
+ * @returns True if commit has no parents
+ */
+function isRootCommit(commit) {
+    return commit.parents.length === 0;
+}
+/**
+ * Extracts the scope from a commit subject if it follows conventional commit format.
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param subject - Commit subject line
+ * @returns Scope string or undefined if no scope found
+ *
+ * @example
+ * extractScope('feat(lib-versioning): add git support') // 'lib-versioning'
+ * extractScope('fix: resolve issue') // undefined
+ */
+function extractScope(subject) {
+    // Look for pattern: type(scope): or type(scope)!:
+    let i = 0;
+    // Skip type characters (a-z)
+    while (i < subject.length) {
+        const code = subject.charCodeAt(i);
+        if (code >= 97 && code <= 122) {
+            // a-z
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    // Must find opening parenthesis
+    if (i >= subject.length || subject[i] !== '(') {
+        return undefined;
+    }
+    // Skip '('
+    i++;
+    const scopeStart = i;
+    // Find closing parenthesis
+    while (i < subject.length && subject[i] !== ')') {
+        i++;
+    }
+    if (i >= subject.length) {
+        return undefined;
+    }
+    const scope = subject.slice(scopeStart, i);
+    return scope || undefined;
+}
+/**
+ * Extracts the type from a commit subject if it follows conventional commit format.
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param subject - Commit subject line
+ * @returns Type string or undefined if no valid type found
+ *
+ * @example
+ * extractType('feat(lib-versioning): add git support') // 'feat'
+ * extractType('fix: resolve issue') // 'fix'
+ * extractType('random message') // undefined
+ */
+function extractType(subject) {
+    let i = 0;
+    // Collect type characters (a-z)
+    while (i < subject.length) {
+        const code = subject.charCodeAt(i);
+        if (code >= 97 && code <= 122) {
+            // a-z
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    if (i === 0) {
+        return undefined;
+    }
+    const type = subject.slice(0, i);
+    // Next character must be '(' , '!' or ':'
+    if (i >= subject.length) {
+        return undefined;
+    }
+    const next = subject[i];
+    if (next === '(' || next === ':' || next === '!') {
+        return type;
+    }
+    return undefined;
+}
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+// Capture references at module initialization time
+const _Math = globalThis.Math;
+// ============================================================================
+// Min/Max
+// ============================================================================
+/**
+ * (Safe copy) Returns the larger of zero or more numbers.
+ */
+const max = _Math.max;
+
+/**
+ * Creates a lightweight git tag.
+ *
+ * @param options - Tag creation options
+ * @returns A new GitTag object
+ *
+ * @example
+ * const tag = createLightweightTag({
+ *   name: 'v1.0.0',
+ *   commitHash: 'abc123...',
+ * })
+ */
+function createLightweightTag(options) {
+    return {
+        name: options.name,
+        commitHash: options.commitHash,
+        type: 'lightweight',
+    };
+}
+/**
+ * Creates an annotated git tag.
+ *
+ * @param options - Tag creation options
+ * @returns A new GitTag object
+ *
+ * @example
+ * const tag = createAnnotatedTag({
+ *   name: 'v1.0.0',
+ *   commitHash: 'abc123...',
+ *   message: 'Release v1.0.0',
+ *   taggerName: 'John Doe',
+ *   taggerEmail: 'john@example.com',
+ *   tagDate: '2026-03-12T10:00:00Z',
+ * })
+ */
+function createAnnotatedTag(options) {
+    return {
+        name: options.name,
+        commitHash: options.commitHash,
+        type: 'annotated',
+        message: options.message,
+        taggerName: options.taggerName,
+        taggerEmail: options.taggerEmail,
+        tagDate: options.tagDate,
+    };
+}
+/**
+ * Checks if a tag is annotated.
+ *
+ * @param tag - Tag to check
+ * @returns True if tag is annotated
+ */
+function isAnnotatedTag(tag) {
+    return tag.type === 'annotated';
+}
+/**
+ * Checks if a tag is lightweight.
+ *
+ * @param tag - Tag to check
+ * @returns True if tag is lightweight
+ */
+function isLightweightTag(tag) {
+    return tag.type === 'lightweight';
+}
+/**
+ * Extracts version from tag name.
+ * Handles common formats: v1.2.3, `@scope/package@1.2.3`, package@1.2.3
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param tagName - Tag name to parse
+ * @returns The extracted version string or undefined if no version found
+ *
+ * @example
+ * extractVersionFromTag('v1.2.3') // '1.2.3'
+ * extractVersionFromTag('@scope/pkg@1.2.3') // '1.2.3'
+ * extractVersionFromTag('release-1.2.3') // '1.2.3'
+ */
+function extractVersionFromTag(tagName) {
+    // Strategy: Find last occurrence of '@' followed by version, or 'v' followed by version
+    // Version starts with digit and contains digits, dots, and possibly prerelease identifiers
+    // First, try to find @version pattern (for scoped packages)
+    let i = tagName.length - 1;
+    // Find last '@'
+    while (i >= 0 && tagName[i] !== '@') {
+        i--;
+    }
+    if (i >= 0) {
+        // Found '@', check if followed by version
+        const afterAt = tagName.slice(i + 1);
+        const version = parseVersionPart(afterAt);
+        if (version) {
+            return version;
+        }
+    }
+    // Try to find 'v' followed by version
+    i = 0;
+    while (i < tagName.length) {
+        if ((tagName[i] === 'v' || tagName[i] === 'V') && i + 1 < tagName.length) {
+            const nextCode = tagName.charCodeAt(i + 1);
+            if (nextCode >= 48 && nextCode <= 57) {
+                // 0-9
+                const version = parseVersionPart(tagName.slice(i + 1));
+                if (version) {
+                    return version;
+                }
+            }
+        }
+        i++;
+    }
+    // Try to find digit sequence after common separators (-, _)
+    i = 0;
+    while (i < tagName.length) {
+        const char = tagName[i];
+        if (char === '-' || char === '_') {
+            const afterSep = tagName.slice(i + 1);
+            const code = afterSep.charCodeAt(0);
+            if (code >= 48 && code <= 57) {
+                // 0-9
+                const version = parseVersionPart(afterSep);
+                if (version) {
+                    return version;
+                }
+            }
+        }
+        i++;
+    }
+    // Last resort: if entire string is a version
+    return parseVersionPart(tagName);
+}
+/**
+ * Parses a version-like string from the start of input.
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param input - String to parse
+ * @returns Version string or undefined
+ */
+function parseVersionPart(input) {
+    if (!input)
+        return undefined;
+    // Must start with digit
+    const firstCode = input.charCodeAt(0);
+    if (firstCode < 48 || firstCode > 57) {
+        return undefined;
+    }
+    // Collect version characters: digits, dots, hyphens, plus, letters (for prerelease)
+    let i = 0;
+    let dotCount = 0;
+    while (i < input.length) {
+        const code = input.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            // 0-9
+            i++;
+        }
+        else if (code === 46) {
+            // .
+            dotCount++;
+            i++;
+        }
+        else if (code === 45) {
+            // -
+            i++;
+        }
+        else if (code === 43) {
+            // +
+            i++;
+        }
+        else if ((code >= 97 && code <= 122) || (code >= 65 && code <= 90)) {
+            // a-z, A-Z
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    // Must have at least one dot (e.g., 1.0)
+    if (dotCount === 0) {
+        return undefined;
+    }
+    const version = input.slice(0, i);
+    // Basic validation: must contain at least two parts separated by dots
+    if (!version.includes('.')) {
+        return undefined;
+    }
+    return version;
+}
+/**
+ * Extracts package name from tag name.
+ * Handles formats like: `@scope/package@1.2.3`, package@1.2.3, package-v1.2.3
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param tagName - Tag name to parse
+ * @returns The extracted package name or undefined if not found
+ *
+ * @example
+ * extractPackageFromTag('@scope/pkg@1.2.3') // '@scope/pkg'
+ * extractPackageFromTag('lib-utils@1.2.3') // 'lib-utils'
+ * extractPackageFromTag('v1.2.3') // undefined
+ */
+function extractPackageFromTag(tagName) {
+    // Find the last '@' that's followed by a version number
+    let lastVersionAt = -1;
+    let i = tagName.length - 1;
+    while (i >= 0) {
+        if (tagName[i] === '@') {
+            // Check if followed by a digit
+            if (i + 1 < tagName.length) {
+                const nextCode = tagName.charCodeAt(i + 1);
+                if (nextCode >= 48 && nextCode <= 57) {
+                    // 0-9
+                    lastVersionAt = i;
+                    break;
+                }
+            }
+        }
+        i--;
+    }
+    if (lastVersionAt > 0) {
+        return tagName.slice(0, lastVersionAt);
+    }
+    // Check for -v or _v pattern
+    i = tagName.length - 1;
+    while (i > 0) {
+        if (tagName[i] === 'v' || tagName[i] === 'V') {
+            const prev = tagName[i - 1];
+            if (prev === '-' || prev === '_') {
+                // Check if followed by digit
+                if (i + 1 < tagName.length) {
+                    const nextCode = tagName.charCodeAt(i + 1);
+                    if (nextCode >= 48 && nextCode <= 57) {
+                        return tagName.slice(0, i - 1);
+                    }
+                }
+            }
+        }
+        i--;
+    }
+    return undefined;
+}
+/**
+ * Builds a tag name from package name and version.
+ *
+ * @param packageName - Package name (e.g., '@scope/package' or 'package')
+ * @param version - Version string (e.g., '1.2.3')
+ * @param format - Tag format template, uses ${package} and ${version} placeholders
+ * @returns Formatted tag name
+ *
+ * @example
+ * buildTagName('@scope/pkg', '1.2.3') // '@scope/pkg@1.2.3'
+ * buildTagName('utils', '1.0.0', 'v${version}') // 'v1.0.0'
+ * buildTagName('pkg', '2.0.0', '${package}-v${version}') // 'pkg-v2.0.0'
+ */
+function buildTagName(packageName, version, format = '${package}@${version}') {
+    // Simple character-by-character replacement (no regex)
+    let result = '';
+    let i = 0;
+    while (i < format.length) {
+        if (i + 9 < format.length && format.slice(i, i + 10) === '${package}') {
+            result += packageName;
+            i += 10;
+        }
+        else if (i + 9 < format.length && format.slice(i, i + 10) === '${version}') {
+            result += version;
+            i += 10;
+        }
+        else {
+            result += format[i];
+            i++;
+        }
+    }
+    return result;
+}
+/**
+ * Compares two tags by version (newest first).
+ * Useful for sorting tags.
+ *
+ * @param a - First tag
+ * @param b - Second tag
+ * @returns Comparison result (-1, 0, or 1)
+ */
+function compareTagsByVersion(a, b) {
+    const versionA = extractVersionFromTag(a.name);
+    const versionB = extractVersionFromTag(b.name);
+    if (!versionA && !versionB)
+        return 0;
+    if (!versionA)
+        return 1;
+    if (!versionB)
+        return -1;
+    return compareVersionStrings(versionB, versionA); // Descending order
+}
+/**
+ * Simple version string comparison.
+ * Compares major.minor.patch numerically.
+ *
+ * @param a - First version
+ * @param b - Second version
+ * @returns Comparison result (-1, 0, or 1)
+ */
+function compareVersionStrings(a, b) {
+    const partsA = a.split('.');
+    const partsB = b.split('.');
+    const maxLen = max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLen; i++) {
+        const numA = parseNumericPart(partsA[i]);
+        const numB = parseNumericPart(partsB[i]);
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Parses numeric part of version segment.
+ *
+ * @param part - Version part to parse
+ * @returns Numeric value
+ */
+function parseNumericPart(part) {
+    if (!part)
+        return 0;
+    // Extract leading digits only
+    let num = 0;
+    for (let i = 0; i < part.length; i++) {
+        const code = part.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            num = num * 10 + (code - 48);
+        }
+        else {
+            break;
+        }
+    }
+    return num;
+}
+
+/**
+ * Creates a git reference from full name.
+ * Parses the reference type from the full name.
+ *
+ * @param options - Reference creation options
+ * @returns A new GitRef object
+ *
+ * @example
+ * const ref = createGitRef({
+ *   fullName: 'refs/heads/main',
+ *   commitHash: 'abc123...',
+ * })
+ */
+function createGitRef(options) {
+    const { type, name, remote } = parseRefName(options.fullName);
+    return {
+        fullName: options.fullName,
+        name,
+        type,
+        commitHash: options.commitHash,
+        remote,
+        isHead: options.isHead,
+    };
+}
+/**
+ * Parses a full reference name into its components.
+ * Uses character-by-character parsing (no regex).
+ *
+ * @param fullName - Full reference name
+ * @returns Parsed components
+ *
+ * @example
+ * parseRefName('refs/heads/main') // { type: 'branch', name: 'main' }
+ * parseRefName('refs/remotes/origin/main') // { type: 'remote', name: 'main', remote: 'origin' }
+ */
+function parseRefName(fullName) {
+    // Handle HEAD specially
+    if (fullName === 'HEAD') {
+        return { type: 'head', name: 'HEAD' };
+    }
+    // Split by '/' character
+    const parts = splitByChar(fullName, '/');
+    // refs/heads/... -> branch
+    if (parts.length >= 3 && parts[0] === 'refs' && parts[1] === 'heads') {
+        return {
+            type: 'branch',
+            name: parts.slice(2).join('/'),
+        };
+    }
+    // refs/tags/... -> tag
+    if (parts.length >= 3 && parts[0] === 'refs' && parts[1] === 'tags') {
+        return {
+            type: 'tag',
+            name: parts.slice(2).join('/'),
+        };
+    }
+    // refs/remotes/origin/... -> remote
+    if (parts.length >= 4 && parts[0] === 'refs' && parts[1] === 'remotes') {
+        return {
+            type: 'remote',
+            name: parts.slice(3).join('/'),
+            remote: parts[2],
+        };
+    }
+    // refs/stash -> stash
+    if (parts.length >= 2 && parts[0] === 'refs' && parts[1] === 'stash') {
+        return {
+            type: 'stash',
+            name: parts.slice(1).join('/'),
+        };
+    }
+    // Default to branch for unknown patterns
+    return {
+        type: 'branch',
+        name: fullName,
+    };
+}
+/**
+ * Splits a string by a character.
+ * Character-by-character implementation (no regex).
+ *
+ * @param str - String to split
+ * @param char - Character to split by
+ * @returns Array of parts
+ */
+function splitByChar(str, char) {
+    const parts = [];
+    let current = '';
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] === char) {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += str[i];
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Checks if a reference is a branch.
+ *
+ * @param ref - Reference to check
+ * @returns True if reference is a branch
+ */
+function isBranchRef(ref) {
+    return ref.type === 'branch';
+}
+/**
+ * Checks if a reference is a tag.
+ *
+ * @param ref - Reference to check
+ * @returns True if reference is a tag
+ */
+function isTagRef(ref) {
+    return ref.type === 'tag';
+}
+/**
+ * Checks if a reference is a remote tracking branch.
+ *
+ * @param ref - Reference to check
+ * @returns True if reference is a remote
+ */
+function isRemoteRef(ref) {
+    return ref.type === 'remote';
+}
+/**
+ * Checks if a reference points to the current HEAD.
+ *
+ * @param ref - Reference to check
+ * @returns True if reference is HEAD
+ */
+function isHeadRef(ref) {
+    return ref.type === 'head' || ref.isHead === true;
+}
+/**
+ * Gets the tracking remote for a reference.
+ *
+ * @param ref - Reference to check
+ * @returns Remote name or undefined
+ */
+function getRemote(ref) {
+    return ref.remote;
+}
+/**
+ * Builds a full reference name from type and name.
+ *
+ * @param type - Reference type
+ * @param name - Reference name
+ * @param remote - Remote name (for remote type)
+ * @returns Full reference name
+ *
+ * @example
+ * buildRefName('branch', 'main') // 'refs/heads/main'
+ * buildRefName('tag', 'v1.0.0') // 'refs/tags/v1.0.0'
+ * buildRefName('remote', 'main', 'origin') // 'refs/remotes/origin/main'
+ */
+function buildRefName(type, name, remote) {
+    switch (type) {
+        case 'branch':
+            return `refs/heads/${name}`;
+        case 'tag':
+            return `refs/tags/${name}`;
+        case 'remote':
+            return remote ? `refs/remotes/${remote}/${name}` : `refs/remotes/${name}`;
+        case 'head':
+            return 'HEAD';
+        case 'stash':
+            return `refs/stash`;
+        default:
+            return name;
+    }
+}
+/**
+ * Compares two references by name (alphabetically).
+ *
+ * @param a - First reference
+ * @param b - Second reference
+ * @returns Comparison result (-1, 0, or 1)
+ */
+function compareRefsByName(a, b) {
+    if (a.name < b.name)
+        return -1;
+    if (a.name > b.name)
+        return 1;
+    return 0;
+}
+/**
+ * Filters references by type.
+ *
+ * @param refs - References to filter
+ * @param type - Type to filter by
+ * @returns Filtered references
+ */
+function filterRefsByType(refs, type) {
+    const result = [];
+    for (const ref of refs) {
+        if (ref.type === type) {
+            result.push(ref);
+        }
+    }
+    return result;
+}
+/**
+ * Filters references by remote.
+ *
+ * @param refs - References to filter
+ * @param remote - Remote name to filter by
+ * @returns Filtered references
+ */
+function filterRefsByRemote(refs, remote) {
+    const result = [];
+    for (const ref of refs) {
+        if (ref.remote === remote) {
+            result.push(ref);
+        }
+    }
+    return result;
+}
+
+exports.buildRefName = buildRefName;
+exports.buildTagName = buildTagName;
+exports.compareRefsByName = compareRefsByName;
+exports.compareTagsByVersion = compareTagsByVersion;
+exports.createAnnotatedTag = createAnnotatedTag;
+exports.createGitCommit = createGitCommit;
+exports.createGitRef = createGitRef;
+exports.createLightweightTag = createLightweightTag;
+exports.extractPackageFromTag = extractPackageFromTag;
+exports.extractScope = extractScope;
+exports.extractType = extractType;
+exports.extractVersionFromTag = extractVersionFromTag;
+exports.filterRefsByRemote = filterRefsByRemote;
+exports.filterRefsByType = filterRefsByType;
+exports.getRemote = getRemote;
+exports.getShortHash = getShortHash;
+exports.isAnnotatedTag = isAnnotatedTag;
+exports.isBranchRef = isBranchRef;
+exports.isHeadRef = isHeadRef;
+exports.isLightweightTag = isLightweightTag;
+exports.isMergeCommit = isMergeCommit;
+exports.isRemoteRef = isRemoteRef;
+exports.isRootCommit = isRootCommit;
+exports.isSameCommit = isSameCommit;
+exports.isTagRef = isTagRef;
+//# sourceMappingURL=index.cjs.js.map