@rglabs/butterfly 2.0.1

package/dist/commands/upload.js

@@ -0,0 +1,150 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text } from 'ink';
+import { join, resolve, basename, dirname } from 'path';
+import { readdir, stat, access } from 'fs/promises';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+import { UploadProgress } from '../components/UploadProgress.js';
+import { UploadHandler } from '../utils/uploadHandler.js';
+async function isPartFolder(dirPath) {
+    const folderName = basename(dirPath);
+    const parentDir = dirname(dirPath);
+    const potentialContainerPath = join(parentDir, `${folderName}.bfy`);
+    try {
+        await access(potentialContainerPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getFilesFromFolder(folderPath) {
+    const files = [];
+    async function traverse(currentPath) {
+        const entries = await readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                if (['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
+                    continue;
+                }
+                if (await isPartFolder(fullPath)) {
+                    continue;
+                }
+                await traverse(fullPath);
+            }
+            else if (entry.isFile()) {
+                const supportedExtensions = ['.json', '.bfy', '.yaml', '.yml', '.js', '.css'];
+                const supportedFiles = ['object.json', 'spec.json', 'report.json', 'task.json', 'page.json', 'cronjob.json', 'template.json', 'layout.json', 'state_machine.json', 'state.json', 'role.json', 'transition.json', 'action.json', 'query.json'];
+                if (supportedExtensions.some(ext => entry.name.endsWith(ext)) || supportedFiles.includes(entry.name)) {
+                    files.push({
+                        path: fullPath,
+                        isFile: true
+                    });
+                }
+            }
+        }
+    }
+    await traverse(folderPath);
+    return files;
+}
+const UploadCommand = ({ targets, api }) => {
+    const [status, setStatus] = useState('loading');
+    const [error, setError] = useState('');
+    const [progress, setProgress] = useState({ current: 0, total: 0, succeeded: 0, failed: 0 });
+    const [currentFile, setCurrentFile] = useState('');
+    const [uploadErrors, setUploadErrors] = useState([]);
+    useEffect(() => {
+        const upload = async () => {
+            try {
+                setStatus('uploading');
+                const allFiles = [];
+                for (const target of targets) {
+                    try {
+                        const resolvedTarget = resolve(target);
+                        const targetStat = await stat(resolvedTarget);
+                        if (targetStat.isDirectory()) {
+                            const files = await getFilesFromFolder(resolvedTarget);
+                            allFiles.push(...files);
+                        }
+                        else if (targetStat.isFile()) {
+                            allFiles.push({
+                                path: resolvedTarget,
+                                isFile: true
+                            });
+                        }
+                        else {
+                            throw new Error(`${resolvedTarget} is neither a file nor a directory`);
+                        }
+                    }
+                    catch (err) {
+                        throw new Error(`Failed to process ${target}: ${err instanceof Error ? err.message : 'Unknown error'}`);
+                    }
+                }
+                setProgress({ current: 0, total: allFiles.length, succeeded: 0, failed: 0 });
+                const uploadHandler = new UploadHandler(api);
+                let succeeded = 0;
+                let failed = 0;
+                const errors = [];
+                for (let i = 0; i < allFiles.length; i++) {
+                    const file = allFiles[i];
+                    setCurrentFile(file.path.split('/').pop() || file.path);
+                    try {
+                        const result = await uploadHandler.uploadFile(file.path);
+                        if (!result.success) {
+                            errors.push({ file: file.path, message: result.message });
+                            failed++;
+                        }
+                        else {
+                            succeeded++;
+                        }
+                        setProgress({ current: i + 1, total: allFiles.length, succeeded, failed });
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        errors.push({ file: file.path, message: errMsg });
+                        failed++;
+                        setProgress({ current: i + 1, total: allFiles.length, succeeded, failed });
+                    }
+                }
+                setUploadErrors(errors);
+                setStatus('complete');
+                setTimeout(() => process.exit(failed > 0 ? 1 : 0), 2000);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : 'Unknown error');
+                setStatus('error');
+                setTimeout(() => process.exit(1), 3000);
+            }
+        };
+        upload();
+    }, [targets]);
+    return (React.createElement(Box, { flexDirection: "column" },
+        status === 'loading' && React.createElement(Text, { color: "gray" }, "..."),
+        status === 'uploading' && (React.createElement(UploadProgress, { current: progress.current, total: progress.total, currentFile: currentFile, status: "uploading", succeeded: progress.succeeded, failed: progress.failed })),
+        status === 'complete' && (React.createElement(React.Fragment, null,
+            React.createElement(UploadProgress, { current: progress.total, total: progress.total, currentFile: "", status: "complete", succeeded: progress.succeeded, failed: progress.failed }),
+            uploadErrors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, { color: "red", bold: true }, "Failed uploads:"),
+                uploadErrors.map((err, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginLeft: 1, marginTop: 1 },
+                    React.createElement(Text, { color: "yellow" },
+                        "\u2022 ",
+                        err.file),
+                    React.createElement(Text, { color: "gray", dimColor: true },
+                        "  ",
+                        err.message)))))))),
+        status === 'error' && (React.createElement(UploadProgress, { current: 0, total: 0, currentFile: "", status: "error", error: error }))));
+};
+export default async (targets) => {
+    const config = await loadAuthConfig();
+    if (!config) {
+        console.error('No authentication configured. Please run "butterfly-cli setup" first.');
+        process.exit(1);
+    }
+    const api = new ButterflyAPI(config);
+    await api.authenticate();
+    if (api.needs2FA)
+        await api.complete2FA();
+    render(React.createElement(UploadCommand, { targets: targets, api: api }));
+};
+//# sourceMappingURL=upload.js.map

package/dist/commands/workflow-info.d.ts

@@ -0,0 +1,13 @@
+import { ButterflyAPI } from '../utils/api.js';
+interface WorkflowInfoProps {
+    api: ButterflyAPI;
+    options: {
+        groups?: boolean;
+        nodes?: string;
+        details?: string;
+        group?: string;
+    };
+}
+export default function workflowInfoCommand(options: WorkflowInfoProps['options']): Promise<void>;
+export {};
+//# sourceMappingURL=workflow-info.d.ts.map

package/dist/commands/workflow-info.js

@@ -0,0 +1,161 @@
+import React, { useEffect, useState } from 'react';
+import { render, Box, Text } from 'ink';
+import { loadAuthConfig } from '../utils/auth.js';
+import { ButterflyAPI } from '../utils/api.js';
+const WorkflowInfoCommand = ({ options, api }) => {
+    const [state, setState] = useState({ status: 'loading', message: 'Initializing...' });
+    useEffect(() => {
+        const run = async () => {
+            try {
+                if (options.groups) {
+                    setState({ status: 'loading', message: 'Fetching node groups...' });
+                    const response = await api.httpClient.get('/admin/bfy_workflow/getWorkflowNodeGroups');
+                    if (response.data?.success) {
+                        setState({
+                            status: 'complete',
+                            message: 'Node Groups:',
+                            data: { type: 'groups', groups: response.data.node_groups }
+                        });
+                    }
+                    else {
+                        setState({ status: 'error', message: response.data?.error || 'Failed to fetch node groups' });
+                    }
+                }
+                else if (options.nodes) {
+                    const group = options.nodes;
+                    setState({ status: 'loading', message: `Fetching nodes in "${group}" group...` });
+                    const response = await api.httpClient.get(`/admin/bfy_workflow/getWorkflowNodes?group=${group}`);
+                    if (response.data?.success) {
+                        setState({
+                            status: 'complete',
+                            message: `Nodes in "${group}" group:`,
+                            data: { type: 'nodes', group, nodes: response.data.nodes }
+                        });
+                    }
+                    else {
+                        setState({ status: 'error', message: response.data?.error || 'Failed to fetch nodes' });
+                    }
+                }
+                else if (options.details && options.group) {
+                    const { group, details: node } = options;
+                    setState({ status: 'loading', message: `Fetching details for "${group}/${node}"...` });
+                    const response = await api.httpClient.get(`/admin/bfy_workflow/getWorkflowNodeDetails?group=${group}&node=${node}`);
+                    if (response.data?.success) {
+                        setState({
+                            status: 'complete',
+                            message: `Node Details: ${group}/${node}`,
+                            data: { type: 'details', node: response.data.node }
+                        });
+                    }
+                    else {
+                        setState({ status: 'error', message: response.data?.error || 'Failed to fetch node details' });
+                    }
+                }
+                else {
+                    setState({
+                        status: 'error',
+                        message: 'Please specify an option: --groups, --nodes <group>, or --details <node> --group <group>'
+                    });
+                }
+            }
+            catch (error) {
+                setState({
+                    status: 'error',
+                    message: error instanceof Error ? error.message : 'Unknown error occurred'
+                });
+            }
+        };
+        run();
+    }, []);
+    const renderGroups = (groups) => {
+        return Object.entries(groups).map(([key, group]) => (React.createElement(Box, { key: key, flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { color: "cyan", bold: true }, group.class_name),
+            React.createElement(Text, { color: "gray" },
+                "  Name: ",
+                group.name),
+            React.createElement(Text, { color: "gray" },
+                "  Description: ",
+                group.description))));
+    };
+    const renderNodes = (nodes, group) => {
+        return nodes.map((node) => (React.createElement(Box, { key: node.id, flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { color: "cyan", bold: true }, node.id),
+            React.createElement(Text, { color: "gray" },
+                "  Name: ",
+                node.name),
+            React.createElement(Text, { color: "gray" },
+                "  Description: ",
+                node.description),
+            React.createElement(Text, { color: "yellow" },
+                "  Usage: --node-group ",
+                group,
+                " --node-type ",
+                node.id))));
+    };
+    const renderDetails = (node) => {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "cyan", bold: true },
+                node.name,
+                " (",
+                node.identifier_key,
+                ")"),
+            React.createElement(Text, { color: "gray" },
+                "Description: ",
+                node.description),
+            node.inputs && Object.keys(node.inputs).length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, { color: "green", bold: true }, "Inputs:"),
+                Object.entries(node.inputs).map(([key, desc]) => (React.createElement(Text, { key: key, color: "gray" },
+                    "  - ",
+                    key,
+                    ": ",
+                    desc))))),
+            node.outputs && Object.keys(node.outputs).length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, { color: "yellow", bold: true }, "Outputs:"),
+                Object.entries(node.outputs).map(([key, desc]) => (React.createElement(Text, { key: key, color: "gray" },
+                    "  - ",
+                    key,
+                    ": ",
+                    desc))))),
+            node.preferences && node.preferences.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, { color: "magenta", bold: true }, "Preferences (params.yaml):"),
+                node.preferences.map((pref, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginLeft: 2 },
+                    React.createElement(Text, { color: "white" },
+                        pref.name,
+                        ": ",
+                        React.createElement(Text, { color: "gray" },
+                            "(",
+                            pref.type,
+                            ")")),
+                    pref.description && React.createElement(Text, { color: "gray" },
+                        "  Description: ",
+                        pref.description),
+                    pref.default !== undefined && React.createElement(Text, { color: "gray" },
+                        "  Default: ",
+                        JSON.stringify(pref.default)),
+                    pref.options && pref.options.length > 0 && (React.createElement(Text, { color: "gray" },
+                        "  Options: ",
+                        pref.options.map(o => o.value).join(', '))))))))));
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        state.status === 'loading' && React.createElement(Text, { color: "yellow" }, state.message),
+        state.status === 'complete' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green", bold: true }, state.message),
+            React.createElement(Text, null, " "),
+            state.data?.type === 'groups' && renderGroups(state.data.groups),
+            state.data?.type === 'nodes' && renderNodes(state.data.nodes, state.data.group),
+            state.data?.type === 'details' && renderDetails(state.data.node))),
+        state.status === 'error' && React.createElement(Text, { color: "red" }, state.message)));
+};
+export default async function workflowInfoCommand(options) {
+    const config = await loadAuthConfig();
+    if (!config) {
+        console.error('No authentication configured. Run "butterfly-cli setup" first.');
+        process.exit(1);
+    }
+    const api = new ButterflyAPI(config);
+    await api.authenticate();
+    if (api.needs2FA)
+        await api.complete2FA();
+    render(React.createElement(WorkflowInfoCommand, { options: options, api: api }));
+}
+//# sourceMappingURL=workflow-info.js.map

package/dist/components/ConflictResolver.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { ResourceDiff } from '../diff/types.js';
+export type ResolveAction = 'keep_local' | 'take_remote' | 'skip';
+interface ConflictResolverProps {
+    diff: ResourceDiff;
+    onResolve: (action: ResolveAction) => void;
+    onShowDetails?: () => void;
+    isApplying?: boolean;
+}
+export declare const ConflictResolver: React.FC<ConflictResolverProps>;
+export default ConflictResolver;
+//# sourceMappingURL=ConflictResolver.d.ts.map

package/dist/components/ConflictResolver.js

@@ -0,0 +1,77 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const ConflictResolver = ({ diff, onResolve, onShowDetails, isApplying = false }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const allActions = [
+        {
+            key: 'l',
+            action: 'keep_local',
+            label: 'Keep Local',
+            description: 'Upload local version to server',
+            enabled: diff.status !== 'remote_only'
+        },
+        {
+            key: 'r',
+            action: 'take_remote',
+            label: 'Take Remote',
+            description: 'Download remote version to local',
+            enabled: diff.status !== 'local_only'
+        },
+        {
+            key: 's',
+            action: 'skip',
+            label: 'Skip',
+            description: 'Do nothing, continue to next',
+            enabled: true
+        }
+    ];
+    const actions = allActions.filter(a => a.enabled);
+    useInput((input, key) => {
+        if (isApplying)
+            return;
+        if (key.leftArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+        }
+        else if (key.rightArrow) {
+            setSelectedIndex(prev => Math.min(actions.length - 1, prev + 1));
+        }
+        if (key.return) {
+            onResolve(actions[selectedIndex].action);
+        }
+        const inputLower = input.toLowerCase();
+        if (inputLower === 'd' && diff.status === 'modified' && onShowDetails) {
+            onShowDetails();
+            return;
+        }
+        for (const action of actions) {
+            if (inputLower === action.key) {
+                onResolve(action.action);
+                break;
+            }
+        }
+        if (key.escape) {
+            onResolve('skip');
+        }
+    });
+    if (isApplying) {
+        return (React.createElement(Box, { marginTop: 1, paddingX: 1 },
+            React.createElement(Text, { color: "blue" }, "Applying changes...")));
+    }
+    return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        React.createElement(Box, { borderStyle: "single", paddingX: 1 },
+            React.createElement(Text, null, "Action: "),
+            actions.map((action, idx) => (React.createElement(Box, { key: action.action, marginLeft: idx > 0 ? 2 : 0 },
+                React.createElement(Text, { color: idx === selectedIndex ? 'cyan' : 'white', bold: idx === selectedIndex, inverse: idx === selectedIndex },
+                    "[",
+                    action.key.toUpperCase(),
+                    "] ",
+                    action.label)))),
+            diff.status === 'modified' && onShowDetails && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "white" }, "[D] Details")))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray" },
+                "Use arrow keys to navigate, Enter to confirm. Shortcuts: L=Keep Local, R=Take Remote, S=Skip",
+                diff.status === 'modified' ? ', D=Details' : ''))));
+};
+export default ConflictResolver;
+//# sourceMappingURL=ConflictResolver.js.map

package/dist/components/DiffView.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { ResourceDiff } from '../diff/types.js';
+interface DiffViewProps {
+    diff: ResourceDiff;
+    currentIndex: number;
+    totalCount: number;
+    showDetails?: boolean;
+}
+export declare const DiffView: React.FC<DiffViewProps>;
+export default DiffView;
+//# sourceMappingURL=DiffView.d.ts.map

package/dist/components/DiffView.js

@@ -0,0 +1,101 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { formatValue } from '../diff/types.js';
+const statusColors = {
+    unchanged: 'gray',
+    modified: 'yellow',
+    local_only: 'green',
+    remote_only: 'red'
+};
+const statusLabels = {
+    unchanged: 'unchanged',
+    modified: 'modified',
+    local_only: 'local only',
+    remote_only: 'remote only'
+};
+const statusSymbols = {
+    unchanged: '=',
+    modified: '~',
+    local_only: '+',
+    remote_only: '-'
+};
+const FieldDiffRow = ({ fieldDiff, detailed = false }) => {
+    const maxLen = detailed ? 500 : 60;
+    return (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1 },
+        React.createElement(Text, { bold: true, color: "white" },
+            fieldDiff.field,
+            ":"),
+        React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, { color: "green" }, "Local:  "),
+            React.createElement(Text, null, formatValue(fieldDiff.localValue, maxLen))),
+        React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, { color: "red" }, "Remote: "),
+            React.createElement(Text, null, formatValue(fieldDiff.remoteValue, maxLen)))));
+};
+const ChildDiffSummary = ({ children, detailed = false }) => {
+    if (children.length === 0)
+        return null;
+    const displayChildren = detailed ? children : children.slice(0, 5);
+    return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        React.createElement(Text, { bold: true, underline: true },
+            "Child Changes (",
+            children.length,
+            "):"),
+        displayChildren.map(child => (React.createElement(Box, { key: child.resourceId, flexDirection: "column", marginLeft: 2 },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: statusColors[child.status] }, statusSymbols[child.status]),
+                React.createElement(Text, null,
+                    " ",
+                    child.resourceName,
+                    " "),
+                React.createElement(Text, { color: "gray" },
+                    "(",
+                    statusLabels[child.status],
+                    ")")),
+            detailed && child.fieldDiffs && child.fieldDiffs.filter(f => f.status !== 'unchanged').length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 }, child.fieldDiffs.filter(f => f.status !== 'unchanged').map(field => (React.createElement(FieldDiffRow, { key: field.field, fieldDiff: field, detailed: true })))))))),
+        !detailed && children.length > 5 && (React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, { color: "gray" },
+                "...and ",
+                children.length - 5,
+                " more")))));
+};
+export const DiffView = ({ diff, currentIndex, totalCount, showDetails = false }) => {
+    const changedFields = diff.fieldDiffs.filter(f => f.status !== 'unchanged');
+    const displayFields = showDetails ? changedFields : changedFields.slice(0, 10);
+    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+        React.createElement(Box, { borderStyle: "single", paddingX: 1, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" },
+                "[",
+                currentIndex + 1,
+                "/",
+                totalCount,
+                "] ",
+                diff.resourceType.toUpperCase(),
+                ": ",
+                diff.resourceName)),
+        React.createElement(Box, null,
+            React.createElement(Text, null, "Status: "),
+            React.createElement(Text, { color: statusColors[diff.status], bold: true }, statusLabels[diff.status]),
+            diff.localPath && (React.createElement(Text, { color: "gray" },
+                " (",
+                diff.localPath,
+                ")"))),
+        diff.status === 'local_only' && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "green" }, "This resource exists locally but not on the remote server."))),
+        diff.status === 'remote_only' && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "red" }, "This resource exists on the remote server but not locally."))),
+        diff.status === 'modified' && changedFields.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { bold: true, underline: true },
+                "Changed Fields (",
+                changedFields.length,
+                "):"),
+            displayFields.map(field => (React.createElement(FieldDiffRow, { key: field.field, fieldDiff: field, detailed: showDetails }))),
+            !showDetails && changedFields.length > 10 && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray" },
+                    "...and ",
+                    changedFields.length - 10,
+                    " more fields"))))),
+        diff.children && diff.children.length > 0 && (React.createElement(ChildDiffSummary, { children: diff.children, detailed: showDetails }))));
+};
+export default DiffView;
+//# sourceMappingURL=DiffView.js.map

package/dist/components/DownloadProgress.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface DownloadProgressProps {
+    resourceType: string;
+    current: number;
+    total: number;
+    status: 'downloading' | 'complete' | 'error';
+    error?: string;
+}
+declare const DownloadProgress: React.FC<DownloadProgressProps>;
+export { DownloadProgress };
+//# sourceMappingURL=DownloadProgress.d.ts.map

package/dist/components/DownloadProgress.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+const DownloadProgress = ({ resourceType, current, total, status, error, }) => {
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, null,
+            status === 'downloading' && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "cyan" },
+                    React.createElement(Spinner, { type: "dots" })),
+                React.createElement(Text, null,
+                    " Downloading ",
+                    resourceType,
+                    "... (",
+                    current,
+                    "/",
+                    total,
+                    ")"))),
+            status === 'complete' && (React.createElement(Text, { color: "green" },
+                "\u2713 Downloaded ",
+                total,
+                " ",
+                resourceType,
+                " successfully!")),
+            status === 'error' && (React.createElement(Text, { color: "red" },
+                "\u2717 Error: ",
+                error)))));
+};
+export { DownloadProgress };
+//# sourceMappingURL=DownloadProgress.js.map

package/dist/components/RecordPreview.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export type OperationType = 'get' | 'add' | 'edit' | 'delete';
+interface RecordPreviewProps {
+    operation: OperationType;
+    table: string;
+    data: Record<string, any>;
+    existingRecord?: Record<string, any>;
+}
+export declare const RecordPreview: React.FC<RecordPreviewProps>;
+export default RecordPreview;
+//# sourceMappingURL=RecordPreview.d.ts.map