n8n-nodes-fasttext-lang 1.0.0

package/dist/FastText.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class FastTextNode implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/FastText.node.js

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastTextNode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Переопределяем fetch для корректной работы с путями к файлам
+if (typeof globalThis.fetch === 'function') {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = function (input, init) {
+        if (typeof input === 'string') {
+            const isLocalFile = (!input.startsWith('http://') &&
+                !input.startsWith('https://') &&
+                !input.startsWith('file://') &&
+                (input.startsWith('/') || input.startsWith('./') || input.startsWith('../') || path.isAbsolute(input)));
+            if (isLocalFile) {
+                return new Promise(function (resolve, reject) {
+                    try {
+                        const bin = fs.readFileSync(input);
+                        const response = new Response(bin.buffer.slice(bin.byteOffset, bin.byteOffset + bin.byteLength), {
+                            status: 200,
+                            statusText: 'OK',
+                            headers: {
+                                'Content-Type': 'application/wasm'
+                            }
+                        });
+                        resolve(response);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            }
+        }
+        return originalFetch.call(this, input, init);
+    };
+}
+const FastText = require('fasttext.js');
+class FastTextNode {
+    constructor() {
+        this.description = {
+            displayName: 'FastText',
+            name: 'fastText',
+            icon: 'file:fasttext.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Detect language using FastText',
+            defaults: {
+                name: 'FastText',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Detect Language',
+                            value: 'detectLanguage',
+                            description: 'Detect the language of the input text',
+                            action: 'Detect language',
+                        },
+                    ],
+                    default: 'detectLanguage',
+                },
+                {
+                    displayName: 'Text',
+                    name: 'text',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['detectLanguage'],
+                        },
+                    },
+                    description: 'Text to detect language for',
+                },
+                {
+                    displayName: 'Model Path',
+                    name: 'modelPath',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'lid.176.bin',
+                    displayOptions: {
+                        show: {
+                            operation: ['detectLanguage'],
+                        },
+                    },
+                    description: 'Path to FastText language detection model (lid.176.bin). Leave empty to use default.',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'detectLanguage') {
+                    const text = this.getNodeParameter('text', i);
+                    let modelPath = this.getNodeParameter('modelPath', i);
+                    // Если путь к модели не указан, используем путь по умолчанию
+                    if (!modelPath) {
+                        // В n8n используем относительный путь от корня проекта
+                        modelPath = path.join(process.cwd(), 'lid.176.bin');
+                    }
+                    // Проверяем существование модели
+                    if (!fs.existsSync(modelPath)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Model not found at path: ${modelPath}`, {
+                            itemIndex: i,
+                        });
+                    }
+                    // Создаем экземпляр FastText
+                    const fastText = new FastText({
+                        loadModel: modelPath,
+                        predict: {
+                            wasm: true,
+                            mostlikely: 1,
+                            verbosity: 0,
+                            normalize: false,
+                        },
+                    });
+                    // Загружаем модель
+                    await fastText.load();
+                    // Определяем язык
+                    const predictions = await fastText.predict(text);
+                    // Обрабатываем результат
+                    if (Array.isArray(predictions) && predictions.length > 0) {
+                        const prediction = predictions[0];
+                        let label, score;
+                        if (Array.isArray(prediction)) {
+                            label = String(prediction[0] || '');
+                            score = Number(prediction[1] || 0);
+                        }
+                        else if (prediction && typeof prediction === 'object') {
+                            label = String(prediction.label || prediction[0] || '');
+                            const scoreValue = prediction.score || prediction.probability || prediction.value || prediction[1];
+                            score = typeof scoreValue === 'string' ? parseFloat(scoreValue) : Number(scoreValue || 0);
+                        }
+                        else {
+                            label = String(prediction || '');
+                            score = 0;
+                        }
+                        // Убираем префикс __label__ если есть
+                        const cleanLabel = label.replace(/^__label__/, '');
+                        returnData.push({
+                            json: {
+                                language: cleanLabel,
+                                confidence: score,
+                                text: text,
+                                confidencePercent: (score * 100).toFixed(2),
+                            },
+                        });
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to detect language', {
+                            itemIndex: i,
+                        });
+                    }
+                    // Выгружаем модель
+                    fastText.unload();
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.FastTextNode = FastTextNode;

package/index.js

@@ -0,0 +1,7 @@
+const FastText = require('./dist/nodes/FastText/FastText.node.js');
+
+module.exports = {
+  nodes: [
+    FastText,
+  ],
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "n8n-nodes-fasttext-lang",
+  "version": "1.0.0",
+  "description": "n8n community node for FastText language detection",
+  "keywords": [
+    "n8n-community-node-package",
+    "fasttext",
+    "language-detection",
+    "nlp"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/yourusername/n8n-node-fasttext",
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/n8n-node-fasttext.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes --write",
+    "lint": "eslint nodes",
+    "lintfix": "eslint nodes --fix",
+    "prepublishOnly": "npm run build && npm run lint -s"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nApiVersion": "1.20.0",
+    "nodes": [
+      "dist/nodes/FastText/FastText.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/parser": "^5.45.0",
+    "eslint-plugin-n8n-nodes-base": "~1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^2.7.1",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "fasttext.js": "^1.1.4",
+    "n8n-workflow": "*"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}