vs-code-ext-from-any-js 1.15.4

package/archive/V4/ForEditorTitle/AddTableName/orchestration/runFeatureOrchestration.js

@@ -0,0 +1,86 @@
+import fs from 'fs';
+import path from 'path';
+
+import * as vscode from 'vscode';
+
+import addTableName from "kschema-api-gen-endpointsjs";
+
+import { fileURLToPath } from 'url';
+
+async function getFolderAndTable() {
+    const input = await vscode.window.showInputBox({
+        prompt: "Enter FolderName and TableName",
+        placeHolder: "Users Tasks"
+    });
+
+    if (!input) return null;
+
+    const clean = input.trim();
+
+    const separators = [' ', '.', ':'];
+
+    let folderName = null;
+    let tableName = null;
+
+    for (const sep of separators) {
+        if (clean.includes(sep)) {
+            const parts = clean.split(sep).map(p => p.trim()).filter(Boolean);
+
+            if (parts.length >= 2) {
+                folderName = parts[0];
+                tableName = parts[1];
+                break;
+            }
+        }
+    }
+
+    // 👉 If only one value → use same for both
+    if (!folderName) {
+        folderName = clean;
+        tableName = clean;
+    }
+
+    // sanitize
+    folderName = folderName.replace(/[^a-zA-Z0-9_]/g, '');
+    tableName = tableName.replace(/[^a-zA-Z0-9_]/g, '');
+
+    return {
+        folderName,
+        tableName
+    };
+};
+
+export async function runFeatureOrchestration({ context }) {
+    const { folderName, tableName } = await getFolderAndTable();
+    // const endpoint = await getEndpoint();
+
+    // fix inside localContext
+    const localContext = {
+        ...context,
+        endpointFolder: path.join(context.targetPath, folderName),
+        routeFilePath: path.join(context.targetPath, folderName),
+        templatePath: fileURLToPath(new URL('../templates/Base', import.meta.url))
+    };
+
+    const funcToRun = await addTableName();
+
+    await funcToRun({
+        showLog: true,
+        isAnnounce: true,
+        folderName,
+        toPath: localContext.targetPath,
+        tableName
+    });
+
+    return { folderName };
+}
+// update only this
+async function getEndpoint() {
+    const value = await vscode.window.showInputBox({ prompt: 'Enter endpoint name (e.g. users)' });
+    if (!value) return null;
+
+    const clean = value.trim().replace(/[^a-zA-Z0-9-_]/g, '');
+    if (!clean) return null;
+
+    return clean;
+};

package/archive/V4/ForEditorTitle/AddTableName/orchestration/startOrchestration.js

@@ -0,0 +1,25 @@
+import { resolveContext } from '../utils/context.js';
+import { finalize } from '../utils/response.js';
+import { runPrechecks } from '../services/precheck.js';
+import { runFeatureOrchestration } from './runFeatureOrchestration.js';
+import { openRoutesFile } from '../services/openFile.js';
+
+export async function startOrchestration({ uri }) {
+    try {
+        const context = resolveContext(uri);
+
+        runPrechecks({
+            targetPath: context.targetPath,
+            appJsPath: context.appJsPath
+        });
+
+        const result = await runFeatureOrchestration({ context });
+        if (!result) return;
+
+        openRoutesFile(`${context.targetPath}/${result.endpoint}`);
+
+        finalize({
+            message: `Endpoint '${result.endpoint}' created 🚀`
+        });
+    } catch (e) { throw e; }
+};

package/archive/V4/ForEditorTitle/AddTableName/services/createStructure.js

@@ -0,0 +1,20 @@
+// src/V3/services/createStructure.js
+
+import fs from 'fs';
+import path from 'path';
+
+export function createStructure({ folderPath, files }) {
+    Object.entries(files).forEach(([relativePath, content]) => {
+        const fullPath = path.join(folderPath, relativePath);
+
+        const dir = path.dirname(fullPath);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        if (!fs.existsSync(fullPath)) {
+            fs.writeFileSync(fullPath, content);
+        }
+    });
+};

package/archive/V4/ForEditorTitle/AddTableName/services/fileService.js

@@ -0,0 +1,16 @@
+// src/V2/services/fileService.js
+
+import fs from 'fs';
+import path from 'path';
+import { entryTemplate } from '../templates/entryTemplate.js';
+
+export function ensureEntryFile({ folderName, dirName }) {
+    const folderPath = path.join(dirName, folderName);
+    const filePath = path.join(folderPath, "entryFile.js");
+
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, entryTemplate());
+    }
+
+    return filePath;
+};

package/archive/V4/ForEditorTitle/AddTableName/services/folderService.js

@@ -0,0 +1,14 @@
+// src/V1/services/folderService.js
+
+import fs from 'fs';
+import path from 'path';
+
+export function ensureFolder({ folderName, dirName }) {
+    const folderPath = path.join(dirName, folderName);
+
+    if (!fs.existsSync(folderPath)) {
+        fs.mkdirSync(folderPath);
+    }
+
+    return folderPath;
+}

package/archive/V4/ForEditorTitle/AddTableName/services/openFile.js

@@ -0,0 +1,17 @@
+// src/V9/InitJs/services/openFile.js;
+
+import * as vscode from 'vscode';
+import path from 'path';
+
+export const openRoutesFile = async (folderPath) => {
+    const fileToOpen = path.join(
+        folderPath,
+        'routes.js'
+    );
+
+    const document = await vscode.workspace.openTextDocument(
+        vscode.Uri.file(fileToOpen)
+    );
+
+    await vscode.window.showTextDocument(document);
+};

package/archive/V4/ForEditorTitle/AddTableName/services/precheck.js

@@ -0,0 +1,18 @@
+// src/V3/AddEndpoint/services/precheck.js
+import fs from 'fs';
+
+export function runPrechecks({ targetPath, appJsPath }) {
+    const log = (msg) => console.log(`[AddEndpoint][${new Date().toISOString()}] ${msg}`);
+
+    if (!fs.existsSync(targetPath)) {
+        log('FAIL: Target folder not found');
+        throw new Error('FOLDER_NOT_FOUND');
+    }
+
+    if (!fs.existsSync(appJsPath)) {
+        log('FAIL: app.js missing');
+        throw new Error('APP_JS_MISSING');
+    }
+
+    log('PASS: Prechecks completed');
+};

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/common/readFile.js

@@ -0,0 +1,8 @@
+import fs from "fs";
+
+const readFile = (inAppJsPath) => {
+    const localPath = inAppJsPath;
+    return fs.readFileSync(localPath, "utf-8");
+};
+
+export default readFile;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/common/writeFile.js

@@ -0,0 +1,10 @@
+import fs from "fs";
+
+const writeFile = (inAppJsPath, inContent) => {
+    const localPath = inAppJsPath;
+    const localContent = inContent;
+
+    fs.writeFileSync(localPath, localContent);
+};
+
+export default writeFile;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/forImports.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+
+export function updateImports({ appJsPath, endpoint }) {
+    try {
+        let content = fs.readFileSync(appJsPath, "utf-8");
+
+        const importLine = `import { router as routerFrom${endpoint} } from "./${endpoint}/routes.js";`;
+
+        function findLastImportIndex() {
+            const regex = /^\s*import.*$/gm;
+            let match, last;
+            
+            while ((match = regex.exec(content)) !== null) last = match;
+            return last ? last.index + last[0].length : -1;
+        };
+
+        function insertLine(index) {
+            if (index === -1 || content.includes(importLine)) return content;
+            return content.slice(0, index) + "\n" + importLine + content.slice(index);
+        };
+
+        const index = findLastImportIndex();
+        content = insertLine(index);
+
+        fs.writeFileSync(appJsPath, content);
+    } catch (e) {
+        console.error("WRITE ERROR:", e);
+    };
+};

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/forUse.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+
+export function updateAppUse({ appJsPath, useLine }) {
+    try {
+        let content = fs.readFileSync(appJsPath, "utf-8");
+
+        function findLastAppUseIndex() {
+            const regex = /app\.use\(.*\);/g;
+            let match, last;
+            while ((match = regex.exec(content)) !== null) last = match;
+            return last ? last.index + last[0].length : -1;
+        }
+
+        function insertLine(index) {
+            if (index === -1 || content.includes(useLine)) return content;
+            return content.slice(0, index) + "\n" + useLine + content.slice(index);
+        }
+
+        const index = findLastAppUseIndex();
+        content = insertLine(index);
+
+        fs.writeFileSync(appJsPath, content);
+    } catch (e) {
+        console.error("APP USE ERROR:", e);
+    }
+};

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/index.js

@@ -0,0 +1,7 @@
+import updateImports from "./updateImports/index.js";
+import updateAppUse from "./updateUse/index.js";
+
+export function updateAppJs({ appJsPath, endpoint }) {
+    updateImports({ appJsPath, endpoint });
+    updateAppUse({ appJsPath, endpoint });
+};

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateImports/buildImport.js

@@ -0,0 +1,9 @@
+const buildImport = (inEndpoint) => {
+    const localEndpoint = inEndpoint;
+
+    const safeName = localEndpoint.replace(/[^a-zA-Z0-9]/g, "_");
+
+    return `import { router as routerFrom${safeName} } from "./${localEndpoint}/routes.js";`;
+};
+
+export default buildImport;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateImports/checkDuplicate.js

@@ -0,0 +1,8 @@
+const checkUseDuplicate = (inContent, inEndpoint) => {
+    const localContent = inContent;
+    const localEndpoint = inEndpoint;
+
+    return localContent.includes(`app.use("/${localEndpoint}"`);
+};
+
+export default checkUseDuplicate;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateImports/findInsertIndex.js

@@ -0,0 +1,10 @@
+const findInsertIndex = (inContent) => {
+    const localContent = inContent;
+
+    const matches = [...localContent.matchAll(/^\s*import.*$/gm)];
+    const last = matches.at(-1);
+
+    return last ? last.index + last[0].length : 0;
+};
+
+export default findInsertIndex;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateImports/index.js

@@ -0,0 +1,41 @@
+import readFile from "../common/readFile.js";
+import buildImport from "./buildImport.js";
+import checkDuplicate from "./checkDuplicate.js";
+import findInsertIndex from "./findInsertIndex.js";
+import writeFile from "../common/writeFile.js";
+
+const updateImports = (inData) => {
+    const localData = inData;
+    const { appJsPath, endpoint } = localData;
+
+    const summary = {
+        import: { added: false, line: null },
+    };
+
+    const content = readFile(appJsPath);
+    const importLine = buildImport(endpoint);
+
+    if (checkDuplicate(content, endpoint)) {
+        summary.import.skipped = true;
+        console.log(summary);
+        return summary;
+    };
+
+    const index = findInsertIndex(content);
+
+    const before = content.slice(0, index);
+    const lineNumber = before.split("\n").length + 1;
+
+    const updated =
+        before + "\n" + importLine + content.slice(index);
+
+    writeFile(appJsPath, updated);
+
+    summary.import.added = true;
+    summary.import.line = lineNumber;
+
+    console.log(summary);
+    return summary;
+};
+
+export default updateImports;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateUse/buildUseLine.js

@@ -0,0 +1,9 @@
+const buildUseLine = (inEndpoint) => {
+    const localEndpoint = inEndpoint;
+
+    const safeName = localEndpoint.replace(/[^a-zA-Z0-9]/g, "_");
+
+    return `app.use("/${localEndpoint}", routerFrom${safeName});`;
+};
+
+export default buildUseLine;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateUse/checkDuplicate.js

@@ -0,0 +1,8 @@
+const checkDuplicate = (inContent, inEndpoint) => {
+    const localContent = inContent;
+    const localEndpoint = inEndpoint;
+
+    return localContent.includes(`app.use("/${localEndpoint}"`);
+};
+
+export default checkDuplicate;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateUse/findInsertIndex.js

@@ -0,0 +1,10 @@
+const findUseInsertIndex = (inContent) => {
+    const localContent = inContent;
+
+    const matches = [...localContent.matchAll(/const\s+app\s*=\s*express\(\)/g)];
+    const match = matches.at(0);
+
+    return match ? match.index + match[0].length : localContent.length;
+};
+
+export default findUseInsertIndex;

package/archive/V4/ForEditorTitle/AddTableName/services/updateAppJs/updateUse/index.js

@@ -0,0 +1,42 @@
+import readFile from "../common/readFile.js";
+import writeFile from "../common/writeFile.js";
+
+import buildUseLine from "./buildUseLine.js";
+import checkDuplicate from "./checkDuplicate.js";
+import findUseInsertIndex from "./findInsertIndex.js";
+
+const updateAppUse = (inData) => {
+    const localData = inData;
+    const { appJsPath, endpoint } = localData;
+
+    const summary = {
+        use: { added: false, skipped: false, line: null }
+    };
+
+    const content = readFile(appJsPath);
+    const useLine = buildUseLine(endpoint);
+
+    if (checkDuplicate(content, endpoint)) {
+        summary.use.skipped = true;
+        console.log(summary);
+        return summary;
+    };
+
+    const index = findUseInsertIndex(content);
+
+    const before = content.slice(0, index);
+    const lineNumber = before.split("\n").length + 1;
+
+    const updated =
+        before + "\n" + useLine + content.slice(index);
+
+    writeFile(appJsPath, updated);
+
+    summary.use.added = true;
+    summary.use.line = lineNumber;
+
+    console.log(summary);
+    return summary;
+};
+
+export default updateAppUse;

package/archive/V4/ForEditorTitle/AddTableName/start.js

@@ -0,0 +1,7 @@
+import { startOrchestration } from './orchestration/startOrchestration.js';
+
+const addSubRoute = (context) => {
+    return async (uri) => startOrchestration({ uri, extensionPath: context.extensionPath });
+};
+
+export default addSubRoute;

package/archive/V4/ForEditorTitle/AddTableName/templates/Base/routes.js

@@ -0,0 +1,5 @@
+import express from 'express';
+
+const router = express.Router();
+
+export { router };

package/archive/V4/ForEditorTitle/AddTableName/utils/capitalize.js

@@ -0,0 +1,7 @@
+// src/V1/utils/capitalize.js
+
+export function capitalizeFirstLetter(value) {
+    if (!value) return value;
+
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/archive/V4/ForEditorTitle/AddTableName/utils/context.js

@@ -0,0 +1,12 @@
+// src/V3/AddEndpoint/utils/context.js
+import path from 'path';
+
+export function resolveContext(uri) {
+    const appJsPath = uri.fsPath;
+    const targetPath = path.dirname(appJsPath);
+
+    return {
+        targetPath,
+        appJsPath
+    };
+};

package/archive/V4/ForEditorTitle/AddTableName/utils/response.js

@@ -0,0 +1,11 @@
+// src/utils/response.js
+
+import * as vscode from 'vscode';
+
+export function finalize({ folderPath }) {
+    vscode.window.showInformationMessage(`Created: ${folderPath}`);
+}
+
+export function fail(error) {
+    vscode.window.showErrorMessage(error.message);
+}

package/archive/V4/ForEditorTitle/appJsFileCommands.js

@@ -0,0 +1,11 @@
+import * as vscode from 'vscode';
+
+import addTableNameCommand from './AddTableName/start.js';
+
+export function registerAllCommands(context) {
+    const command = 'extension.editor.title.routesjs.addTableName';
+
+    const CreateEndpoint = vscode.commands.registerCommand(command, addTableNameCommand(context));
+
+    context.subscriptions.push(CreateEndpoint);
+};

package/archive/V4/ForEditorTitle/registerCommands.js

@@ -0,0 +1,5 @@
+import { registerAllCommands as appJsFileCommands } from "./appJsFileCommands.js";
+
+export function registerAllCommands(context) {
+    appJsFileCommands(context);
+};

package/archive/V4/ForEditorTitle/utils/capitalize.js

@@ -0,0 +1,7 @@
+// src/V1/utils/capitalize.js
+
+export function capitalizeFirstLetter(value) {
+    if (!value) return value;
+
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/archive/V4/ForEditorTitle/utils/context.js

@@ -0,0 +1,12 @@
+// src/V3/AddEndpoint/utils/context.js
+import path from 'path';
+
+export function resolveContext(uri) {
+    const appJsPath = uri.fsPath;
+    const targetPath = path.dirname(appJsPath);
+
+    return {
+        targetPath,
+        appJsPath
+    };
+};

package/archive/V4/ForEditorTitle/utils/response.js

@@ -0,0 +1,11 @@
+// src/utils/response.js
+
+import * as vscode from 'vscode';
+
+export function finalize({ folderPath }) {
+    vscode.window.showInformationMessage(`Created: ${folderPath}`);
+}
+
+export function fail(error) {
+    vscode.window.showErrorMessage(error.message);
+}

package/archive/V4/frontEnd/addListeners/fromHeaderJson/backend/readHtml.js

@@ -0,0 +1,96 @@
+import * as vscode from 'vscode';
+import fs from 'fs';
+import path from 'path';
+
+import { getHtmlWithScripts } from "./utils/htmlLoader.js";
+import { handleWebviewMessage } from "./services/messageRouter.js";
+import { getWorkspaceContext } from "./utils/workspaceHelper.js";
+
+const findHtmlFolder = (startDir) => {
+    let currentDir = path.resolve(startDir);
+    while (currentDir) {
+        const indexPath = path.join(currentDir, 'index.html');
+        if (fs.existsSync(indexPath)) {
+            return currentDir;
+        }
+        try {
+            const files = fs.readdirSync(currentDir);
+            const hasHtml = files.some(file => file.toLowerCase().endsWith('.html'));
+            if (hasHtml) {
+                return currentDir;
+            }
+        } catch (error) {
+            // Ignore directory read errors
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return null;
+};
+
+const findHeadersJsonPath = (startDir) => {
+    let currentDir = path.resolve(startDir);
+
+    while (currentDir) {
+        const headersJsonPath = path.join(currentDir, 'headers.json');
+        if (fs.existsSync(headersJsonPath)) {
+            return currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    };
+
+    return null;
+};
+
+const extractIdsFromJson = (inJsonPath) => {
+    const headersJsonPath = path.join(inJsonPath, 'headers.json');
+
+    try {
+        const rawData = fs.readFileSync(headersJsonPath, 'utf8');
+        const jsonData = JSON.parse(rawData);
+
+        const idArray = jsonData.items.map(element => {
+            return element.id;
+        });
+
+        return idArray;
+    } catch (error) {
+        console.error('Error:', error);
+    };
+};
+
+const activateHtml = (context, uri) => {
+    const panel = vscode.window.createWebviewPanel(
+        "showHtml",
+        "Show Html",
+        vscode.ViewColumn.One,
+        { enableScripts: true }
+    );
+
+    panel.webview.html = getHtmlWithScripts();
+
+    panel.webview.onDidReceiveMessage(async (message) => {
+        const { userRootFolder, schemasPath, folderPath, port } = getWorkspaceContext(uri);
+        const headersJsonPath = findHeadersJsonPath(folderPath);
+        const ids = extractIdsFromJson(headersJsonPath);
+
+        await handleWebviewMessage({
+            message,
+            panel,
+            toPath: folderPath,
+            port,
+            inTargetPath: userRootFolder,
+            ids
+        });
+    });
+};
+
+export default activateHtml;
+

package/archive/V4/frontEnd/addListeners/fromHeaderJson/backend/services/actions/addTableName.js

@@ -0,0 +1,15 @@
+import hookListener from 'kschema-ui-hook-add-listeners';
+import { executeGenerationTask } from "../generatorService.js";
+
+const startFunc = async ({ panel, tableName, toPath, inFolderName }) => {
+    await executeGenerationTask({
+        panel,
+        actionLabel: "Add Table Name",
+        tableName,
+        toPath,
+        generateFunc: hookListener,
+        inFolderName
+    });
+};
+
+export default startFunc;