@memberjunction/core-actions 2.47.0 → 2.49.0

package/dist/custom/text-analyzer.action.js

@@ -0,0 +1,218 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadTextAnalyzerAction = exports.TextAnalyzerAction = void 0;
+const actions_1 = require("@memberjunction/actions");
+const global_1 = require("@memberjunction/global");
+/**
+ * Action that analyzes text content and provides various statistics including
+ * word count, character count, readability scores, and common word analysis.
+ *
+ * @example
+ * ```typescript
+ * // Analyze a simple text
+ * await runAction({
+ *   ActionName: 'Text Analyzer',
+ *   Params: [{
+ *     Name: 'Text',
+ *     Value: 'The quick brown fox jumps over the lazy dog.'
+ *   }]
+ * });
+ *
+ * // Analyze with custom options
+ * await runAction({
+ *   ActionName: 'Text Analyzer',
+ *   Params: [{
+ *     Name: 'Text',
+ *     Value: 'Your text here...'
+ *   }, {
+ *     Name: 'IncludeWordFrequency',
+ *     Value: true
+ *   }]
+ * });
+ * ```
+ */
+let TextAnalyzerAction = class TextAnalyzerAction extends actions_1.BaseAction {
+    /**
+     * Executes the text analysis action
+     *
+     * @param params - The action parameters containing:
+     *   - Text: The text content to analyze
+     *   - IncludeWordFrequency: Optional boolean to include word frequency analysis
+     *
+     * @returns A promise resolving to an ActionResultSimple with text analysis data
+     */
+    async InternalRunAction(params) {
+        try {
+            const textParam = params.Params.find(p => p.Name === 'Text');
+            const includeFreqParam = params.Params.find(p => p.Name === 'IncludeWordFrequency');
+            if (!textParam || !textParam.Value) {
+                return {
+                    Success: false,
+                    Message: "Text parameter is required",
+                    ResultCode: "MISSING_PARAMETERS"
+                };
+            }
+            const text = textParam.Value;
+            const includeFrequency = includeFreqParam?.Value === true || includeFreqParam?.Value === 'true';
+            // Basic counts
+            const charCount = text.length;
+            const charCountNoSpaces = text.replace(/\s/g, '').length;
+            const words = this.extractWords(text);
+            const wordCount = words.length;
+            const sentences = this.extractSentences(text);
+            const sentenceCount = sentences.length;
+            const paragraphs = text.split(/\n\n+/).filter(p => p.trim().length > 0);
+            const paragraphCount = paragraphs.length;
+            const lines = text.split('\n').filter(l => l.trim().length > 0);
+            const lineCount = lines.length;
+            // Calculate averages
+            const avgWordLength = wordCount > 0 ?
+                words.reduce((sum, word) => sum + word.length, 0) / wordCount : 0;
+            const avgWordsPerSentence = sentenceCount > 0 ? wordCount / sentenceCount : 0;
+            const avgWordsPerParagraph = paragraphCount > 0 ? wordCount / paragraphCount : 0;
+            // Readability scores
+            const fleschScore = this.calculateFleschReadingEase(avgWordsPerSentence, avgWordLength);
+            const readingLevel = this.getReadingLevel(fleschScore);
+            // Character analysis
+            const letterCount = text.match(/[a-zA-Z]/g)?.length || 0;
+            const digitCount = text.match(/\d/g)?.length || 0;
+            const punctuationCount = text.match(/[.,;:!?'"()\-]/g)?.length || 0;
+            const whitespaceCount = text.match(/\s/g)?.length || 0;
+            // Build result
+            const analysisData = {
+                summary: {
+                    characters: charCount,
+                    charactersNoSpaces: charCountNoSpaces,
+                    words: wordCount,
+                    sentences: sentenceCount,
+                    paragraphs: paragraphCount,
+                    lines: lineCount
+                },
+                averages: {
+                    wordLength: parseFloat(avgWordLength.toFixed(2)),
+                    wordsPerSentence: parseFloat(avgWordsPerSentence.toFixed(2)),
+                    wordsPerParagraph: parseFloat(avgWordsPerParagraph.toFixed(2))
+                },
+                characterBreakdown: {
+                    letters: letterCount,
+                    digits: digitCount,
+                    punctuation: punctuationCount,
+                    whitespace: whitespaceCount,
+                    other: charCount - letterCount - digitCount - punctuationCount - whitespaceCount
+                },
+                readability: {
+                    fleschReadingEase: parseFloat(fleschScore.toFixed(2)),
+                    readingLevel: readingLevel,
+                    estimatedReadingTimeMinutes: parseFloat((wordCount / 200).toFixed(2))
+                }
+            };
+            // Add word frequency if requested
+            if (includeFrequency && words.length > 0) {
+                const frequency = this.calculateWordFrequency(words);
+                analysisData.wordFrequency = {
+                    uniqueWords: frequency.size,
+                    topWords: Array.from(frequency.entries())
+                        .sort((a, b) => b[1] - a[1])
+                        .slice(0, 20)
+                        .map(([word, count]) => ({ word, count, percentage: parseFloat((count / wordCount * 100).toFixed(2)) }))
+                };
+            }
+            // Language detection hints
+            const hasNumbers = digitCount > 0;
+            const hasUppercase = text !== text.toLowerCase();
+            const hasPunctuation = punctuationCount > 0;
+            analysisData.textFeatures = {
+                hasNumbers,
+                hasUppercase,
+                hasPunctuation,
+                appearsToBe: this.guessTextType(avgWordsPerSentence, hasPunctuation, paragraphCount)
+            };
+            return {
+                Success: true,
+                ResultCode: "SUCCESS",
+                Message: JSON.stringify(analysisData, null, 2)
+            };
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `Failed to analyze text: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "FAILED"
+            };
+        }
+    }
+    extractWords(text) {
+        // Extract words (sequences of letters and digits)
+        return text.match(/\b[\w']+\b/g)?.map(w => w.toLowerCase()) || [];
+    }
+    extractSentences(text) {
+        // Simple sentence extraction (ends with . ! ? followed by space or end)
+        return text.match(/[^.!?]+[.!?]+/g)?.map(s => s.trim()).filter(s => s.length > 0) || [text];
+    }
+    calculateWordFrequency(words) {
+        const frequency = new Map();
+        const commonWords = new Set(['the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have',
+            'i', 'it', 'for', 'not', 'on', 'with', 'he', 'as', 'you', 'do', 'at', 'this',
+            'but', 'his', 'by', 'from', 'is', 'was', 'are', 'been', 'has', 'had', 'were',
+            'said', 'did', 'get', 'may', 'will', 'would', 'could', 'can', 'if', 'or', 'an']);
+        for (const word of words) {
+            if (word.length > 2 && !commonWords.has(word)) {
+                frequency.set(word, (frequency.get(word) || 0) + 1);
+            }
+        }
+        return frequency;
+    }
+    calculateFleschReadingEase(avgWordsPerSentence, avgWordLength) {
+        // Simplified Flesch Reading Ease formula
+        // Using average word length as proxy for syllables (divide by 3 for rough estimate)
+        const avgSyllablesPerWord = avgWordLength / 3;
+        const score = 206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord;
+        return Math.max(0, Math.min(100, score));
+    }
+    getReadingLevel(fleschScore) {
+        if (fleschScore >= 90)
+            return "Very Easy (5th grade)";
+        if (fleschScore >= 80)
+            return "Easy (6th grade)";
+        if (fleschScore >= 70)
+            return "Fairly Easy (7th grade)";
+        if (fleschScore >= 60)
+            return "Plain English (8th-9th grade)";
+        if (fleschScore >= 50)
+            return "Fairly Difficult (10th-12th grade)";
+        if (fleschScore >= 30)
+            return "Difficult (College)";
+        if (fleschScore >= 10)
+            return "Very Difficult (Graduate)";
+        return "Extremely Difficult (Professional)";
+    }
+    guessTextType(avgWordsPerSentence, hasPunctuation, paragraphCount) {
+        if (!hasPunctuation)
+            return "List or notes";
+        if (avgWordsPerSentence < 10)
+            return "Simple text or dialogue";
+        if (avgWordsPerSentence > 25)
+            return "Academic or technical writing";
+        if (paragraphCount > 3)
+            return "Article or essay";
+        return "General text";
+    }
+};
+exports.TextAnalyzerAction = TextAnalyzerAction;
+exports.TextAnalyzerAction = TextAnalyzerAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "__TextAnalyzer")
+], TextAnalyzerAction);
+/**
+ * Loader function to ensure the TextAnalyzerAction class is included in the bundle.
+ */
+function LoadTextAnalyzerAction() {
+    // this function is a stub that is used to force the bundler to include the above class in the final bundle and not tree shake them out
+}
+exports.LoadTextAnalyzerAction = LoadTextAnalyzerAction;
+//# sourceMappingURL=text-analyzer.action.js.map

package/dist/custom/text-analyzer.action.js.map

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

package/dist/custom/unit-converter.action.d.ts

@@ -0,0 +1,63 @@
+import { ActionResultSimple, RunActionParams } from "@memberjunction/actions-base";
+import { BaseAction } from "@memberjunction/actions";
+/**
+ * Action that converts values between different units of measurement.
+ * Supports length, weight, temperature, volume, area, speed, and time conversions.
+ *
+ * @example
+ * ```typescript
+ * // Convert miles to kilometers
+ * await runAction({
+ *   ActionName: 'Unit Converter',
+ *   Params: [{
+ *     Name: 'Value',
+ *     Value: 5
+ *   }, {
+ *     Name: 'FromUnit',
+ *     Value: 'miles'
+ *   }, {
+ *     Name: 'ToUnit',
+ *     Value: 'kilometers'
+ *   }]
+ * });
+ *
+ * // Convert temperature
+ * await runAction({
+ *   ActionName: 'Unit Converter',
+ *   Params: [{
+ *     Name: 'Value',
+ *     Value: 32
+ *   }, {
+ *     Name: 'FromUnit',
+ *     Value: 'fahrenheit'
+ *   }, {
+ *     Name: 'ToUnit',
+ *     Value: 'celsius'
+ *   }]
+ * });
+ * ```
+ */
+export declare class UnitConverterAction extends BaseAction {
+    private conversions;
+    /**
+     * Executes the unit conversion action
+     *
+     * @param params - The action parameters containing:
+     *   - Value: The numeric value to convert
+     *   - FromUnit: The unit to convert from
+     *   - ToUnit: The unit to convert to
+     *
+     * @returns A promise resolving to an ActionResultSimple with conversion data
+     */
+    protected InternalRunAction(params: RunActionParams): Promise<ActionResultSimple>;
+    private isTemperature;
+    private convertTemperature;
+    private getTemperatureFormula;
+    private formatResult;
+    private getAlternativeConversions;
+}
+/**
+ * Loader function to ensure the UnitConverterAction class is included in the bundle.
+ */
+export declare function LoadUnitConverterAction(): void;
+//# sourceMappingURL=unit-converter.action.d.ts.map

package/dist/custom/unit-converter.action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-converter.action.d.ts","sourceRoot":"","sources":["../../src/custom/unit-converter.action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAe,MAAM,8BAA8B,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBACa,mBAAoB,SAAQ,UAAU;IAC/C,OAAO,CAAC,WAAW,CAsEjB;IAEF;;;;;;;;;OASG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuIvF,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,kBAAkB;IA2C1B,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,yBAAyB;CAyBpC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,SAEtC"}

package/dist/custom/unit-converter.action.js

@@ -0,0 +1,357 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadUnitConverterAction = exports.UnitConverterAction = void 0;
+const actions_1 = require("@memberjunction/actions");
+const global_1 = require("@memberjunction/global");
+/**
+ * Action that converts values between different units of measurement.
+ * Supports length, weight, temperature, volume, area, speed, and time conversions.
+ *
+ * @example
+ * ```typescript
+ * // Convert miles to kilometers
+ * await runAction({
+ *   ActionName: 'Unit Converter',
+ *   Params: [{
+ *     Name: 'Value',
+ *     Value: 5
+ *   }, {
+ *     Name: 'FromUnit',
+ *     Value: 'miles'
+ *   }, {
+ *     Name: 'ToUnit',
+ *     Value: 'kilometers'
+ *   }]
+ * });
+ *
+ * // Convert temperature
+ * await runAction({
+ *   ActionName: 'Unit Converter',
+ *   Params: [{
+ *     Name: 'Value',
+ *     Value: 32
+ *   }, {
+ *     Name: 'FromUnit',
+ *     Value: 'fahrenheit'
+ *   }, {
+ *     Name: 'ToUnit',
+ *     Value: 'celsius'
+ *   }]
+ * });
+ * ```
+ */
+let UnitConverterAction = class UnitConverterAction extends actions_1.BaseAction {
+    conversions = {
+        // Length conversions (base: meters)
+        length: {
+            meter: 1, meters: 1, m: 1,
+            kilometer: 0.001, kilometers: 0.001, km: 0.001,
+            centimeter: 100, centimeters: 100, cm: 100,
+            millimeter: 1000, millimeters: 1000, mm: 1000,
+            mile: 0.000621371, miles: 0.000621371, mi: 0.000621371,
+            yard: 1.09361, yards: 1.09361, yd: 1.09361,
+            foot: 3.28084, feet: 3.28084, ft: 3.28084,
+            inch: 39.3701, inches: 39.3701, in: 39.3701,
+            nautical_mile: 0.000539957, nautical_miles: 0.000539957, nmi: 0.000539957
+        },
+        // Weight conversions (base: grams)
+        weight: {
+            gram: 1, grams: 1, g: 1,
+            kilogram: 0.001, kilograms: 0.001, kg: 0.001,
+            milligram: 1000, milligrams: 1000, mg: 1000,
+            pound: 0.00220462, pounds: 0.00220462, lb: 0.00220462, lbs: 0.00220462,
+            ounce: 0.035274, ounces: 0.035274, oz: 0.035274,
+            ton: 0.000001, tons: 0.000001, t: 0.000001,
+            metric_ton: 0.000001, metric_tons: 0.000001,
+            stone: 0.000157473, stones: 0.000157473
+        },
+        // Volume conversions (base: liters)
+        volume: {
+            liter: 1, liters: 1, l: 1,
+            milliliter: 1000, milliliters: 1000, ml: 1000,
+            gallon: 0.264172, gallons: 0.264172, gal: 0.264172,
+            quart: 1.05669, quarts: 1.05669, qt: 1.05669,
+            pint: 2.11338, pints: 2.11338, pt: 2.11338,
+            cup: 4.22675, cups: 4.22675,
+            fluid_ounce: 33.814, fluid_ounces: 33.814, fl_oz: 33.814,
+            tablespoon: 67.628, tablespoons: 67.628, tbsp: 67.628,
+            teaspoon: 202.884, teaspoons: 202.884, tsp: 202.884,
+            cubic_meter: 0.001, cubic_meters: 0.001, m3: 0.001,
+            cubic_foot: 0.0353147, cubic_feet: 0.0353147, ft3: 0.0353147
+        },
+        // Area conversions (base: square meters)
+        area: {
+            square_meter: 1, square_meters: 1, m2: 1, sqm: 1,
+            square_kilometer: 0.000001, square_kilometers: 0.000001, km2: 0.000001,
+            square_mile: 0.000000386102, square_miles: 0.000000386102, mi2: 0.000000386102,
+            square_yard: 1.19599, square_yards: 1.19599, yd2: 1.19599,
+            square_foot: 10.7639, square_feet: 10.7639, ft2: 10.7639, sqft: 10.7639,
+            square_inch: 1550, square_inches: 1550, in2: 1550,
+            hectare: 0.0001, hectares: 0.0001, ha: 0.0001,
+            acre: 0.000247105, acres: 0.000247105, ac: 0.000247105
+        },
+        // Speed conversions (base: meters per second)
+        speed: {
+            meters_per_second: 1, mps: 1, 'm/s': 1,
+            kilometers_per_hour: 3.6, kph: 3.6, kmh: 3.6, 'km/h': 3.6,
+            miles_per_hour: 2.23694, mph: 2.23694, 'mi/h': 2.23694,
+            feet_per_second: 3.28084, fps: 3.28084, 'ft/s': 3.28084,
+            knots: 1.94384, knot: 1.94384, kn: 1.94384
+        },
+        // Time conversions (base: seconds)
+        time: {
+            second: 1, seconds: 1, s: 1, sec: 1,
+            millisecond: 1000, milliseconds: 1000, ms: 1000,
+            microsecond: 1000000, microseconds: 1000000, μs: 1000000,
+            nanosecond: 1000000000, nanoseconds: 1000000000, ns: 1000000000,
+            minute: 0.0166667, minutes: 0.0166667, min: 0.0166667,
+            hour: 0.000277778, hours: 0.000277778, h: 0.000277778, hr: 0.000277778,
+            day: 0.0000115741, days: 0.0000115741, d: 0.0000115741,
+            week: 0.00000165344, weeks: 0.00000165344, wk: 0.00000165344,
+            month: 0.00000038052, months: 0.00000038052, mo: 0.00000038052,
+            year: 0.0000000316881, years: 0.0000000316881, yr: 0.0000000316881
+        }
+    };
+    /**
+     * Executes the unit conversion action
+     *
+     * @param params - The action parameters containing:
+     *   - Value: The numeric value to convert
+     *   - FromUnit: The unit to convert from
+     *   - ToUnit: The unit to convert to
+     *
+     * @returns A promise resolving to an ActionResultSimple with conversion data
+     */
+    async InternalRunAction(params) {
+        try {
+            const valueParam = params.Params.find(p => p.Name === 'Value');
+            const fromUnitParam = params.Params.find(p => p.Name === 'FromUnit');
+            const toUnitParam = params.Params.find(p => p.Name === 'ToUnit');
+            if (!valueParam || valueParam.Value === undefined || valueParam.Value === null) {
+                return {
+                    Success: false,
+                    Message: "Value parameter is required",
+                    ResultCode: "MISSING_PARAMETERS"
+                };
+            }
+            if (!fromUnitParam || !fromUnitParam.Value) {
+                return {
+                    Success: false,
+                    Message: "FromUnit parameter is required",
+                    ResultCode: "MISSING_PARAMETERS"
+                };
+            }
+            if (!toUnitParam || !toUnitParam.Value) {
+                return {
+                    Success: false,
+                    Message: "ToUnit parameter is required",
+                    ResultCode: "MISSING_PARAMETERS"
+                };
+            }
+            const value = parseFloat(valueParam.Value.toString());
+            if (isNaN(value)) {
+                return {
+                    Success: false,
+                    Message: "Value must be a valid number",
+                    ResultCode: "INVALID_VALUE"
+                };
+            }
+            const fromUnit = fromUnitParam.Value.toLowerCase().replace(/\s+/g, '_');
+            const toUnit = toUnitParam.Value.toLowerCase().replace(/\s+/g, '_');
+            // Handle temperature separately as it's not a simple multiplication
+            if (this.isTemperature(fromUnit) || this.isTemperature(toUnit)) {
+                const result = this.convertTemperature(value, fromUnit, toUnit);
+                if (result === null) {
+                    return {
+                        Success: false,
+                        Message: `Cannot convert between ${fromUnit} and ${toUnit}`,
+                        ResultCode: "INCOMPATIBLE_UNITS"
+                    };
+                }
+                const conversionData = {
+                    original: {
+                        value: value,
+                        unit: fromUnitParam.Value
+                    },
+                    converted: {
+                        value: result,
+                        unit: toUnitParam.Value,
+                        formatted: `${result.toFixed(2)} ${toUnitParam.Value}`
+                    },
+                    category: 'temperature',
+                    formula: this.getTemperatureFormula(fromUnit, toUnit)
+                };
+                return {
+                    Success: true,
+                    ResultCode: "SUCCESS",
+                    Message: JSON.stringify(conversionData, null, 2)
+                };
+            }
+            // Find the category for both units
+            let fromCategory = null;
+            let toCategory = null;
+            for (const [category, units] of Object.entries(this.conversions)) {
+                if (units[fromUnit])
+                    fromCategory = category;
+                if (units[toUnit])
+                    toCategory = category;
+            }
+            if (!fromCategory || !toCategory) {
+                return {
+                    Success: false,
+                    Message: `Unknown unit(s): ${!fromCategory ? fromUnit : ''} ${!toCategory ? toUnit : ''}`,
+                    ResultCode: "UNKNOWN_UNIT"
+                };
+            }
+            if (fromCategory !== toCategory) {
+                return {
+                    Success: false,
+                    Message: `Cannot convert between ${fromCategory} and ${toCategory} units`,
+                    ResultCode: "INCOMPATIBLE_UNITS"
+                };
+            }
+            // Perform conversion
+            const fromFactor = this.conversions[fromCategory][fromUnit];
+            const toFactor = this.conversions[fromCategory][toUnit];
+            const baseValue = value / fromFactor;
+            const result = baseValue * toFactor;
+            const conversionData = {
+                original: {
+                    value: value,
+                    unit: fromUnitParam.Value
+                },
+                converted: {
+                    value: result,
+                    unit: toUnitParam.Value,
+                    formatted: this.formatResult(result, toUnitParam.Value)
+                },
+                category: fromCategory,
+                conversionFactor: toFactor / fromFactor,
+                alternativeUnits: this.getAlternativeConversions(baseValue, fromCategory, toUnit)
+            };
+            return {
+                Success: true,
+                ResultCode: "SUCCESS",
+                Message: JSON.stringify(conversionData, null, 2)
+            };
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `Failed to convert units: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "FAILED"
+            };
+        }
+    }
+    isTemperature(unit) {
+        const tempUnits = ['celsius', 'c', 'fahrenheit', 'f', 'kelvin', 'k'];
+        return tempUnits.includes(unit);
+    }
+    convertTemperature(value, from, to) {
+        // Normalize unit names
+        const normalizeTemp = (unit) => {
+            if (unit === 'c')
+                return 'celsius';
+            if (unit === 'f')
+                return 'fahrenheit';
+            if (unit === 'k')
+                return 'kelvin';
+            return unit;
+        };
+        from = normalizeTemp(from);
+        to = normalizeTemp(to);
+        if (from === to)
+            return value;
+        // Convert to Celsius first
+        let celsius;
+        switch (from) {
+            case 'celsius':
+                celsius = value;
+                break;
+            case 'fahrenheit':
+                celsius = (value - 32) * 5 / 9;
+                break;
+            case 'kelvin':
+                celsius = value - 273.15;
+                break;
+            default:
+                return null;
+        }
+        // Convert from Celsius to target
+        switch (to) {
+            case 'celsius':
+                return celsius;
+            case 'fahrenheit':
+                return celsius * 9 / 5 + 32;
+            case 'kelvin':
+                return celsius + 273.15;
+            default:
+                return null;
+        }
+    }
+    getTemperatureFormula(from, to) {
+        const formulas = {
+            'celsius_fahrenheit': '°F = °C × 9/5 + 32',
+            'fahrenheit_celsius': '°C = (°F - 32) × 5/9',
+            'celsius_kelvin': 'K = °C + 273.15',
+            'kelvin_celsius': '°C = K - 273.15',
+            'fahrenheit_kelvin': 'K = (°F - 32) × 5/9 + 273.15',
+            'kelvin_fahrenheit': '°F = (K - 273.15) × 9/5 + 32'
+        };
+        return formulas[`${from}_${to}`] || '';
+    }
+    formatResult(value, unit) {
+        // Format based on the magnitude of the result
+        if (Math.abs(value) < 0.01 || Math.abs(value) > 10000) {
+            return `${value.toExponential(4)} ${unit}`;
+        }
+        else if (Number.isInteger(value)) {
+            return `${value} ${unit}`;
+        }
+        else {
+            // Determine decimal places based on value
+            const decimals = Math.abs(value) < 1 ? 4 : 2;
+            return `${value.toFixed(decimals)} ${unit}`;
+        }
+    }
+    getAlternativeConversions(baseValue, category, excludeUnit) {
+        const alternatives = [];
+        const commonUnits = {
+            length: ['meters', 'kilometers', 'miles', 'feet'],
+            weight: ['grams', 'kilograms', 'pounds', 'ounces'],
+            volume: ['liters', 'milliliters', 'gallons', 'cups'],
+            area: ['square_meters', 'square_feet', 'acres', 'hectares'],
+            speed: ['kilometers_per_hour', 'miles_per_hour', 'meters_per_second'],
+            time: ['seconds', 'minutes', 'hours', 'days']
+        };
+        const unitsToShow = commonUnits[category] || [];
+        for (const unit of unitsToShow) {
+            if (unit !== excludeUnit && this.conversions[category][unit]) {
+                const value = baseValue * this.conversions[category][unit];
+                alternatives.push({
+                    unit: unit.replace(/_/g, ' '),
+                    value: parseFloat(value.toFixed(4))
+                });
+            }
+        }
+        return alternatives;
+    }
+};
+exports.UnitConverterAction = UnitConverterAction;
+exports.UnitConverterAction = UnitConverterAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "__UnitConverter")
+], UnitConverterAction);
+/**
+ * Loader function to ensure the UnitConverterAction class is included in the bundle.
+ */
+function LoadUnitConverterAction() {
+    // this function is a stub that is used to force the bundler to include the above class in the final bundle and not tree shake them out
+}
+exports.LoadUnitConverterAction = LoadUnitConverterAction;
+//# sourceMappingURL=unit-converter.action.js.map