@grunnverk/kodrdriv 1.3.0 → 1.5.0

package/temp-dist/util/storage.js

@@ -1,149 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import * as fs from 'fs';
-import { glob } from 'glob';
-import path from 'path';
-import crypto from 'crypto';
-export const create = (params) => {
-    // eslint-disable-next-line no-console
-    const log = params.log || console.log;
-    const exists = async (path) => {
-        try {
-            await fs.promises.stat(path);
-            return true;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (error) {
-            return false;
-        }
-    };
-    const isDirectory = async (path) => {
-        const stats = await fs.promises.stat(path);
-        if (!stats.isDirectory()) {
-            // Log at debug level since this is expected when scanning directories
-            // that contain both files and directories
-            return false;
-        }
-        return true;
-    };
-    const isFile = async (path) => {
-        const stats = await fs.promises.stat(path);
-        if (!stats.isFile()) {
-            // Log removed since this is expected when checking file types
-            return false;
-        }
-        return true;
-    };
-    const isReadable = async (path) => {
-        try {
-            await fs.promises.access(path, fs.constants.R_OK);
-        }
-        catch (error) {
-            log(`${path} is not readable: %s %s`, error.message, error.stack);
-            return false;
-        }
-        return true;
-    };
-    const isWritable = async (path) => {
-        try {
-            await fs.promises.access(path, fs.constants.W_OK);
-        }
-        catch (error) {
-            log(`${path} is not writable: %s %s`, error.message, error.stack);
-            return false;
-        }
-        return true;
-    };
-    const isFileReadable = async (path) => {
-        return await exists(path) && await isFile(path) && await isReadable(path);
-    };
-    const isDirectoryWritable = async (path) => {
-        return await exists(path) && await isDirectory(path) && await isWritable(path);
-    };
-    const isDirectoryReadable = async (path) => {
-        return await exists(path) && await isDirectory(path) && await isReadable(path);
-    };
-    const createDirectory = async (path) => {
-        try {
-            await fs.promises.mkdir(path, { recursive: true });
-        }
-        catch (mkdirError) {
-            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
-        }
-    };
-    const ensureDirectory = async (path) => {
-        if (!(await exists(path))) {
-            await createDirectory(path);
-        }
-    };
-    const removeDirectory = async (path) => {
-        try {
-            if (await exists(path)) {
-                await fs.promises.rm(path, { recursive: true, force: true });
-            }
-        }
-        catch (rmError) {
-            throw new Error(`Failed to remove directory ${path}: ${rmError.message} ${rmError.stack}`);
-        }
-    };
-    const readFile = async (path, encoding) => {
-        return await fs.promises.readFile(path, { encoding: encoding });
-    };
-    const writeFile = async (path, data, encoding) => {
-        await fs.promises.writeFile(path, data, { encoding: encoding });
-    };
-    const rename = async (oldPath, newPath) => {
-        await fs.promises.rename(oldPath, newPath);
-    };
-    const deleteFile = async (path) => {
-        try {
-            if (await exists(path)) {
-                await fs.promises.unlink(path);
-            }
-        }
-        catch (deleteError) {
-            throw new Error(`Failed to delete file ${path}: ${deleteError.message} ${deleteError.stack}`);
-        }
-    };
-    const forEachFileIn = async (directory, callback, options = { pattern: '*.*' }) => {
-        try {
-            const files = await glob(options.pattern, { cwd: directory, nodir: true });
-            for (const file of files) {
-                await callback(path.join(directory, file));
-            }
-        }
-        catch (err) {
-            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
-        }
-    };
-    const readStream = async (path) => {
-        return fs.createReadStream(path);
-    };
-    const hashFile = async (path, length) => {
-        const file = await readFile(path, 'utf8');
-        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
-    };
-    const listFiles = async (directory) => {
-        return await fs.promises.readdir(directory);
-    };
-    return {
-        exists,
-        isDirectory,
-        isFile,
-        isReadable,
-        isWritable,
-        isFileReadable,
-        isDirectoryWritable,
-        isDirectoryReadable,
-        createDirectory,
-        ensureDirectory,
-        readFile,
-        readStream,
-        writeFile,
-        rename,
-        deleteFile,
-        forEachFileIn,
-        hashFile,
-        listFiles,
-        removeDirectory,
-    };
-};

package/temp-dist/util/validation.js

@@ -1,110 +0,0 @@
-/**
- * Runtime validation utilities for safe type handling
- */
-/**
- * Validates and safely casts data to ReleaseSummary type
- */
-export const validateReleaseSummary = (data) => {
-    if (!data || typeof data !== 'object') {
-        throw new Error('Invalid release summary: not an object');
-    }
-    if (typeof data.title !== 'string') {
-        throw new Error('Invalid release summary: title must be a string');
-    }
-    if (typeof data.body !== 'string') {
-        throw new Error('Invalid release summary: body must be a string');
-    }
-    return data;
-};
-/**
- * Validates and safely casts data to LinkBackup type
- */
-export const validateLinkBackup = (data) => {
-    if (!data || typeof data !== 'object') {
-        throw new Error('Invalid link backup: not an object');
-    }
-    // Validate each backup entry
-    for (const [key, value] of Object.entries(data)) {
-        if (!value || typeof value !== 'object') {
-            throw new Error(`Invalid link backup entry for ${key}: not an object`);
-        }
-        const entry = value;
-        if (typeof entry.originalVersion !== 'string') {
-            throw new Error(`Invalid link backup entry for ${key}: originalVersion must be a string`);
-        }
-        if (typeof entry.dependencyType !== 'string') {
-            throw new Error(`Invalid link backup entry for ${key}: dependencyType must be a string`);
-        }
-        if (typeof entry.relativePath !== 'string') {
-            throw new Error(`Invalid link backup entry for ${key}: relativePath must be a string`);
-        }
-    }
-    return data;
-};
-/**
- * Validates transcription result has required text property
- */
-export const validateTranscriptionResult = (data) => {
-    if (!data || typeof data !== 'object') {
-        throw new Error('Invalid transcription result: not an object');
-    }
-    if (typeof data.text !== 'string') {
-        throw new Error('Invalid transcription result: text property must be a string');
-    }
-    return data;
-};
-/**
- * Safely parses JSON with error handling
- */
-export const safeJsonParse = (jsonString, context) => {
-    try {
-        const parsed = JSON.parse(jsonString);
-        if (parsed === null || parsed === undefined) {
-            throw new Error('Parsed JSON is null or undefined');
-        }
-        return parsed;
-    }
-    catch (error) {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Failed to parse JSON${contextStr}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-};
-/**
- * Validates that a value is a non-empty string
- */
-export const validateString = (value, fieldName) => {
-    if (typeof value !== 'string') {
-        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
-    }
-    if (value.trim() === '') {
-        throw new Error(`${fieldName} cannot be empty`);
-    }
-    return value;
-};
-/**
- * Validates that a value exists and has a specific property
- */
-export const validateHasProperty = (obj, property, context) => {
-    if (!obj || typeof obj !== 'object') {
-        const contextStr = context ? ` in ${context}` : '';
-        throw new Error(`Object is null or not an object${contextStr}`);
-    }
-    if (!(property in obj)) {
-        const contextStr = context ? ` in ${context}` : '';
-        throw new Error(`Missing required property '${property}'${contextStr}`);
-    }
-};
-/**
- * Validates package.json structure has basic required fields
- */
-export const validatePackageJson = (data, context, requireName = true) => {
-    if (!data || typeof data !== 'object') {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Invalid package.json${contextStr}: not an object`);
-    }
-    if (requireName && typeof data.name !== 'string') {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Invalid package.json${contextStr}: name must be a string`);
-    }
-    return data;
-};