@oxeo/visual 0.0.0-stage → 0.2.0

package/dist/text.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeXml = exports.plural = void 0;
+const plural = (n, forms) => {
+    const m10 = n % 10;
+    const m100 = n % 100;
+    const form = m10 === 1 && m100 !== 11 ? 0 : m10 >= 2 && m10 <= 4 && (m100 < 10 || m100 >= 20) ? 1 : 2;
+    return `${n} ${forms[form]}`;
+};
+exports.plural = plural;
+const escapeXml = (text) => text.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);
+exports.escapeXml = escapeXml;

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+export declare class TypeCatalog {
+    private readonly program;
+    readonly types: Record<string, string>;
+    private readonly ids;
+    private readonly checker;
+    constructor(program: ts.Program);
+    refsOf(typeNode: ts.TypeNode | undefined): string[];
+    private collect;
+    private resolve;
+    private declare;
+    private text;
+    private inline;
+}
+export declare const compilerOptions: (tsconfig?: string) => ts.CompilerOptions;

package/dist/types.js

@@ -0,0 +1,143 @@
+"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.compilerOptions = exports.TypeCatalog = void 0;
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const MAX_DEPTH = 3;
+const MAX_DECLARATIONS = 12;
+const MAX_INLINE = 240;
+const isTypeDeclaration = (node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node);
+const isOpaque = (decl) => {
+    if (!ts.isTypeAliasDeclaration(decl))
+        return false;
+    const opaque = (node) => ts.isTypeQueryNode(node) ||
+        ts.isTypeOperatorNode(node) ||
+        ts.isIndexedAccessTypeNode(node) ||
+        Boolean(ts.forEachChild(node, opaque));
+    return opaque(decl.type);
+};
+class TypeCatalog {
+    constructor(program) {
+        this.program = program;
+        this.types = {};
+        this.ids = new Map();
+        this.checker = program.getTypeChecker();
+    }
+    refsOf(typeNode) {
+        const out = [];
+        if (typeNode)
+            this.collect(typeNode, out, 0);
+        return out;
+    }
+    collect(node, out, depth) {
+        const visit = (n) => {
+            const name = ts.isTypeReferenceNode(n)
+                ? n.typeName
+                : ts.isExpressionWithTypeArguments(n)
+                    ? n.expression
+                    : undefined;
+            const decl = name && out.length < MAX_DECLARATIONS ? this.resolve(name) : undefined;
+            if (decl) {
+                const id = this.declare(decl);
+                if (!out.includes(id)) {
+                    out.push(id);
+                    if (depth < MAX_DEPTH && !isOpaque(decl))
+                        this.collect(decl, out, depth + 1);
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(node);
+    }
+    resolve(name) {
+        let symbol = this.checker.getSymbolAtLocation(name);
+        if (symbol && symbol.flags & ts.SymbolFlags.Alias)
+            symbol = this.checker.getAliasedSymbol(symbol);
+        const decl = symbol?.declarations?.find(isTypeDeclaration);
+        if (!decl)
+            return undefined;
+        const source = decl.getSourceFile();
+        const standard = this.program.isSourceFileDefaultLibrary(source) ||
+            /[\\/]typescript[\\/]lib[\\/]/.test(source.fileName);
+        return standard ? undefined : decl;
+    }
+    declare(decl) {
+        const known = this.ids.get(decl);
+        if (known)
+            return known;
+        const name = decl.name.text;
+        const id = name in this.types ? `${name} (${path.basename(decl.getSourceFile().fileName)})` : name;
+        this.ids.set(decl, id);
+        this.types[id] = isOpaque(decl) ? this.inline(decl) : this.text(decl);
+        return id;
+    }
+    text(decl) {
+        const source = decl.getSourceFile();
+        const indent = source.getLineAndCharacterOfPosition(decl.getStart()).character;
+        return decl
+            .getText()
+            .replace(/^export\s+(declare\s+)?/, '')
+            .split('\n')
+            .map((line, i) => i === 0 ? line : line.slice(Math.min(indent, line.length - line.trimStart().length)))
+            .join('\n');
+    }
+    inline(decl) {
+        const type = this.checker.getTypeAtLocation(decl.name);
+        let text = this.checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseSingleQuotesForStringLiteralType);
+        if (text.length > MAX_INLINE)
+            text = `${text.slice(0, MAX_INLINE - 1)}…`;
+        return `type ${decl.name.text} = ${text}`;
+    }
+}
+exports.TypeCatalog = TypeCatalog;
+const compilerOptions = (tsconfig) => {
+    if (tsconfig) {
+        const { config } = ts.readConfigFile(tsconfig, ts.sys.readFile);
+        return {
+            ...ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(tsconfig)).options,
+            noEmit: true
+        };
+    }
+    return {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10,
+        experimentalDecorators: true,
+        skipLibCheck: true,
+        noEmit: true
+    };
+};
+exports.compilerOptions = compilerOptions;

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@oxeo/visual",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Интерактивная карта схемы данных oxeo: модели, поля, embedded-блоки и связи по исходникам схемы.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/troovi/oxeo.git",
+    "directory": "tools/visual"
+  },
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "oxeo-visual": "bin/oxeo-visual.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "echo": "echo \"@oxeo/visual\"",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsc -p tsconfig.client.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json"
+  },
+  "dependencies": {
+    "libavoid-js": "0.4.5",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "ts-node": ">=10"
+  },
+  "peerDependenciesMeta": {
+    "ts-node": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "*"
+  }
 }