@antv/vis-predict-engine

--- package.json (entry) ---
{
  "name": "@antv/vis-predict-engine",
  "version": "0.1.1",
  "description": "visualization predict engine",
  "repository": {
    "type": "git",
    "url": "https://github.com/antvis/vis-predict-engine"
  },
  "license": "MIT",
  "author": "https://github.com/orgs/antvis/people",
  "main": "dist/index",
  "files": [
    "package.json",
    "dist",
    "LICENSE",
    "README.md"
  ],
  "scripts": {
    "start": "father build --watch",
    "build": "npm run clean && father build",
    "clean": "rimraf es esm lib dist",
    "lint": "eslint --ext .js,.jsx,.ts,.tsx --format=pretty \"./\"",
    "prettier": "prettier -c --write \"**/*\""
  },
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged"
    }
  },
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "prettier --write",
      "eslint --ext .js,.jsx,.ts,.tsx",
      "git add"
    ]
  },
  "devDependencies": {
    "eslint": "^7.13.0",
    "father": "^2.29.11",
    "lint-staged": "^10.5.1",
    "pre-commit": "^1.2.2",
    "prettier": "^2.1.2",
    "rimraf": "^3.0.2"
  },
  "dependencies": {
    "@tensorflow/tfjs": "^2.7.0"
  }
}


--- index.js (entry) ---
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var tf = require('@tensorflow/tfjs');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var tf__namespace = /*#__PURE__*/_interopNamespace(tf);

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);

    if (enumerableOnly) {
      symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
    }

    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKe

--- bundled output (OSV-MAL flagged — LLM scope expansion) ---

--- dist/index.d.ts (bundled) ---
import { GraphLayoutPredict } from './graph-predict';
export { GraphLayoutPredict };


--- dist/index.esm.js (bundled) ---
import * as tf from '@tensorflow/tfjs';
import { layers, serialization, initializers, tidy, dot, tensor2d, softmax, diag, pow, tensor, loadLayersModel } from '@tensorflow/tfjs';

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);

    if (enumerableOnly) {
      symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
    }

    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

function _classCallCheck(instance, Constr

--- dist/index.js (bundled) ---
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var tf = require('@tensorflow/tfjs');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var tf__namespace = /*#__PURE__*/_interopNamespace(tf);

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);

    if (enumerableOnly) {
      symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
    }

    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () 

--- dist/graph-predict/index.d.ts (bundled) ---
import GraphLayoutPredict from './layout';
export { GraphLayoutPredict };


--- dist/graph-predict/types/index.d.ts (bundled) ---
export interface PlainObject {
    [key: string]: any;
}
export interface Node {
    id: string;
    label: string;
    properties?: PlainObject;
    [key: string]: any;
}
export interface Edge {
    id: string;
    name?: string;
    label?: string;
    source: string;
    target: string;
    properties?: PlainObject;
    [key: string]: any;
}
export interface GraphData {
    nodes: Node[];
    edges: Edge[];
}
export declare type Layout = 'force' | 'radial' | 'concentric' | 'circular';
export interface FinalNode {
    id: string;
}
export interface FinalEdge {
    source?: string;
    target?: string;
    from: string;
    to: string;
}
export interface PredictGraphData {
    nodes: FinalNode[];
    edges: FinalEdge[];
}


--- dist/graph-predict/layout/index.d.ts (bundled) ---
import './layer/graph-conv-layer';
import './layer/pooling-layer';
import { Layout, GraphData } from '../types';
declare const _default: {
    predict(data: GraphData, expectLayout?: Layout | undefined, showLog?: boolean | undefined): Promise<{
        predictLayout: Layout;
        confidence: string;
    } | {
        predictLayout?: undefined;
        confidence?: undefined;
    }>;
};
export default _default;


--- dist/graph-predict/layout/utils/index.d.ts (bundled) ---
import * as tf from '@tensorflow/tfjs';
import { GraphData, Layout, FinalNode, FinalEdge } from '../../types';
export declare const featureProcess: (nodes: FinalNode[], edges: FinalEdge[], featureCount: number) => tf.Tensor<tf.Rank>[];
export declare const transGraphData: (data: GraphData) => {
    nodes: FinalNode[];
    edges: FinalEdge[];
};
export declare const predictLog: (predictedRes: Layout, confidence: string, expectLayout?: Layout | undefined) => void;
declare const _default: {
    featureProcess: (nodes: FinalNode[], edges: FinalEdge[], featureCount: number) => tf.Tensor<tf.Rank>[];
    transGraphData: (data: GraphData) => {
        nodes: FinalNode[];
        edges: FinalEdge[];
    };
    predictLog: (predictedRes: Layout, confidence: string, expectLayout?: Layout | undefined) => void;
};
export default _default;


--- dist/graph-predict/layout/layer/graph-conv-layer.d.ts (bundled) ---
export default GraphConvLayer;
declare class GraphConvLayer extends tf.layers.Layer {
    constructor(options: any);
    useBias: boolean;
    biasInitializer: import("@tensorflow/tfjs/node_modules/@tensorflow/tfjs-layers/dist/initializers").Zeros;
    biasRegularizer: any;
    kernel: tf.LayerVariable | undefined;
    bias: tf.LayerVariable | null | undefined;
}
declare namespace GraphConvLayer {
    const className: string;
}
import * as tf from "@tensorflow/tfjs";


--- dist/graph-predict/layout/layer/pooling-layer.d.ts (bundled) ---
export default GraphPoolingLayer;
declare class GraphPoolingLayer extends tf.layers.Layer {
}
declare namespace GraphPoolingLayer {
    const className: string;
}
import * as tf from "@tensorflow/tfjs";