@larsgw/formica 0.1.0

package/lib/bin/util.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = exports.promptForAnswers = exports.prompt = exports.numericSort = void 0;
+var readline = require("readline");
+var child_process_1 = require("child_process");
+/**
+ * Comparison function to sort strings with numerical components.
+ */
+function numericSort(a, b) {
+    var as = a.split(/(\d+)/);
+    var bs = b.split(/(\d+)/);
+    for (var i = 0; i < Math.max(as.length, bs.length); i++) {
+        var ai = as[i];
+        var bi = bs[i];
+        if (ai === bi) {
+            continue;
+        }
+        else if (!ai) {
+            return 1;
+        }
+        else if (!bi) {
+            return -1;
+        }
+        else if (i % 2) {
+            return parseInt(ai) - parseInt(bi);
+        }
+        else {
+            return ai > bi ? -1 : 1;
+        }
+    }
+    return 0;
+}
+exports.numericSort = numericSort;
+/**
+ * Create a CLI prompt and return any answer.
+ */
+function prompt(question) {
+    var rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(function (resolve) {
+        rl.question(question, function (answer) {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+exports.prompt = prompt;
+/**
+ * Create a CLI prompt and only accept certain answers.
+ */
+function promptForAnswers(question, answers) {
+    return __awaiter(this, void 0, void 0, function () {
+        var answer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, prompt(question)];
+                case 1:
+                    answer = (_a.sent())[0];
+                    _a.label = 2;
+                case 2:
+                    if (!answers.includes(answer)) return [3 /*break*/, 0];
+                    _a.label = 3;
+                case 3: return [2 /*return*/, answer];
+            }
+        });
+    });
+}
+exports.promptForAnswers = promptForAnswers;
+/**
+ * Run a command and return stdout.
+ */
+function runCommand(command, args, options) {
+    return new Promise(function (resolve, reject) {
+        var proc = (0, child_process_1.spawn)(command, args, options);
+        var stdout = '';
+        proc.stdout.on('data', function (data) { stdout += data; });
+        proc.on('close', function (code) {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject();
+            }
+        });
+    });
+}
+exports.runCommand = runCommand;

package/lib/bin/validate-catalog.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/validate-catalog.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path = require("path");
+var index_1 = require("../index");
+function validateFile(arg) {
+    return __awaiter(this, void 0, void 0, function () {
+        var filePath, file, sheet;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    filePath = path.resolve(arg);
+                    return [4 /*yield*/, fs_1.promises.readFile(filePath, 'utf8')];
+                case 1:
+                    file = _a.sent();
+                    sheet = path.basename(filePath, '.csv');
+                    return [2 /*return*/, {
+                            filePath: filePath,
+                            errors: index_1.catalog.loadData(file, sheet).validate()
+                        }];
+            }
+        });
+    });
+}
+function main(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var exitStatus, results, _i, results_1, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    exitStatus = 0;
+                    return [4 /*yield*/, Promise.allSettled(args.map(validateFile))];
+                case 1:
+                    results = _a.sent();
+                    for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
+                        result = results_1[_i];
+                        if (result.status === 'rejected') {
+                            console.error(result.reason);
+                            console.error();
+                            exitStatus = 1;
+                        }
+                        else if (result.value.errors.length > 0) {
+                            console.error("".concat(result.value.filePath, ":"));
+                            console.table(result.value.errors);
+                            console.error();
+                            exitStatus = 1;
+                        }
+                    }
+                    process.exit(exitStatus);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main(process.argv.slice(2));

package/lib/bin/validate-resources-text.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/validate-resources-text.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var path = require("path");
+var index_1 = require("../index");
+function main(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var exitStatus, _i, args_1, arg, filePath, file, id;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    exitStatus = 0;
+                    _i = 0, args_1 = args;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < args_1.length)) return [3 /*break*/, 4];
+                    arg = args_1[_i];
+                    filePath = path.resolve(arg);
+                    return [4 /*yield*/, fs_1.promises.readFile(filePath, 'utf8')];
+                case 2:
+                    file = _a.sent();
+                    id = path.basename(filePath, '.txt');
+                    try {
+                        index_1.resources.parseTextFile(file, id);
+                    }
+                    catch (error) {
+                        console.error(filePath + '\n    ' + error.message + '\n');
+                        exitStatus = 1;
+                    }
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    process.exit(exitStatus);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main(process.argv.slice(2));

package/lib/catalog/entities.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from './entity';
+export declare class Entities {
+    entities: Entity[];
+    indexField: string;
+    index: Record<string, Entity>;
+    constructor(entities: Entity[], indexField: string);
+    [Symbol.iterator](): Generator<Entity, void, unknown>;
+    get(key: string): Entity;
+    has(key: string): boolean;
+    validate(): WorkError[];
+    toTable(): string[][];
+}

package/lib/catalog/entities.js

@@ -0,0 +1,111 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entities = void 0;
+var Entities = /** @class */ (function () {
+    function Entities(entities, indexField) {
+        this.entities = entities;
+        this.indexField = indexField;
+        this.index = {};
+        for (var _i = 0, _a = this.entities; _i < _a.length; _i++) {
+            var entity = _a[_i];
+            var key = entity.get(indexField);
+            if (typeof key !== 'string') {
+                throw new TypeError('Entity missing index field');
+            }
+            this.index[key] = entity;
+        }
+    }
+    Entities.prototype[Symbol.iterator] = function () {
+        var _i, _a, entity;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _i = 0, _a = this.entities;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < _a.length)) return [3 /*break*/, 4];
+                    entity = _a[_i];
+                    return [4 /*yield*/, entity];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    };
+    Entities.prototype.get = function (key) {
+        return this.index[key];
+    };
+    Entities.prototype.has = function (key) {
+        return key in this.index;
+    };
+    Entities.prototype.validate = function () {
+        var errors = [];
+        for (var _i = 0, _a = this.entities; _i < _a.length; _i++) {
+            var entity = _a[_i];
+            for (var _b = 0, _c = entity.validate(); _b < _c.length; _b++) {
+                var _d = _c[_b], field = _d.field, error = _d.error;
+                errors.push({
+                    entity: (entity.get(this.indexField) || '[missing]'),
+                    field: field,
+                    error: error
+                });
+            }
+        }
+        return errors;
+    };
+    Entities.prototype.toTable = function () {
+        if (this.entities.length === 0) {
+            return [[]];
+        }
+        var header = Object.keys(this.entities[0].fields);
+        var table = this.entities.map(function (entity) {
+            return header.map(function (field) {
+                var value = entity.get(field) || '';
+                return Array.isArray(value) ? value.join('; ') : value;
+            });
+        });
+        return __spreadArray([header], table, true);
+    };
+    return Entities;
+}());
+exports.Entities = Entities;

package/lib/catalog/entity.d.ts

@@ -0,0 +1,13 @@
+export declare class Entity {
+    fields: Record<string, Value>;
+    schema: Schema;
+    derivedFields: Record<string, Value>;
+    constructor(values: Record<string, string>, schema: Schema);
+    deriveFields(): void;
+    get(key: string): Value | undefined;
+    has(key: string): boolean;
+    validate(): FieldError[];
+    _validateField(field: string): string[];
+    _validateValueCount(field: string, value: Value): string | undefined;
+    _validateSingleValue(field: string, value: SingleValue): string | undefined;
+}

package/lib/catalog/entity.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+var value_1 = require("./value");
+var Entity = /** @class */ (function () {
+    function Entity(values, schema) {
+        this.fields = {};
+        for (var key in values) {
+            var value = (0, value_1.parseValue)(values[key], !!schema[key].multiple);
+            if (value !== null) {
+                this.fields[key] = value;
+            }
+        }
+        this.schema = schema;
+        this.derivedFields = {};
+    }
+    /* eslint-disable @typescript-eslint/no-empty-function */
+    Entity.prototype.deriveFields = function () {
+    };
+    /* eslint-enable @typescript-eslint/no-empty-function */
+    Entity.prototype.get = function (key) {
+        if (key in this.fields) {
+            return this.fields[key];
+        }
+        else if (key in this.derivedFields) {
+            return this.derivedFields[key];
+        }
+    };
+    Entity.prototype.has = function (key) {
+        return key in this.fields || key in this.derivedFields;
+    };
+    Entity.prototype.validate = function () {
+        var errors = [];
+        for (var field in this.fields) {
+            for (var _i = 0, _a = this._validateField(field); _i < _a.length; _i++) {
+                var error = _a[_i];
+                errors.push({ field: field, error: error });
+            }
+        }
+        return errors;
+    };
+    Entity.prototype._validateField = function (field) {
+        var errors = [];
+        if (!(field in this.fields)) {
+            if (this.schema[field].required) {
+                errors.push('Value(s) required but missing');
+            }
+            return errors;
+        }
+        var valueCountError = this._validateValueCount(field, this.fields[field]);
+        if (valueCountError !== undefined) {
+            errors.push(valueCountError);
+        }
+        var values = this.fields[field];
+        if (!Array.isArray(values)) {
+            values = [values];
+        }
+        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+            var value = values_1[_i];
+            var result = this._validateSingleValue(field, value);
+            if (result !== undefined) {
+                errors.push(result);
+            }
+        }
+        return errors;
+    };
+    Entity.prototype._validateValueCount = function (field, value) {
+        var multipleConfig = this.schema[field].multiple;
+        var allowMultiple = typeof multipleConfig === 'function'
+            ? multipleConfig.call(null, this.fields)
+            : multipleConfig;
+        if (allowMultiple === false) {
+            var multiple = false;
+            if (Array.isArray(value) && value.length > 2) {
+                multiple = true;
+            }
+            else if (typeof value === 'string' && value.includes('; ')) {
+                multiple = true;
+            }
+            if (multiple) {
+                return 'Multiple values but only one expected';
+            }
+        }
+        return undefined;
+    };
+    Entity.prototype._validateSingleValue = function (field, value) {
+        var config = this.schema[field].format;
+        if (config === undefined) {
+            return undefined;
+        }
+        else if (Array.isArray(config) && (value === null || !config.includes(value))) {
+            return "The value \"".concat(value, "\" is not included: ").concat(config.join(', '));
+        }
+        else if (config instanceof RegExp && !config.test(value)) {
+            return "The value \"".concat(value, "\" does not conform to pattern: ").concat(config.source);
+        }
+        else if (typeof config === 'function' && !config.call(null, value)) {
+            return "The value \"".concat(value, "\" does not conform to pattern: ").concat(config.name);
+        }
+    };
+    return Entity;
+}());
+exports.Entity = Entity;

package/lib/catalog/index.d.ts

@@ -0,0 +1,4 @@
+import { Entities } from './entities';
+import { Entity } from './entity';
+export { Entities, Entity };
+export declare function loadData(file: string, type: string): Entities;

package/lib/catalog/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadData = exports.Entity = exports.Entities = void 0;
+var entities_1 = require("./entities");
+Object.defineProperty(exports, "Entities", { enumerable: true, get: function () { return entities_1.Entities; } });
+var entity_1 = require("./entity");
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return entity_1.Entity; } });
+var index_1 = require("./tables/index");
+var csv_1 = require("../csv");
+function getTypeInfo(type) {
+    switch (type) {
+        case 'authors': return index_1.TYPE_INFO.authors;
+        case 'places': return index_1.TYPE_INFO.places;
+        case 'publishers': return index_1.TYPE_INFO.publishers;
+        case 'catalog': return index_1.TYPE_INFO.catalog;
+        default: throw new TypeError("Unknown type \"".concat(type, "\""));
+    }
+}
+function loadData(file, type) {
+    var _a = getTypeInfo(type), subClass = _a[0], indexField = _a[1];
+    var entities = [];
+    var _b = (0, csv_1.parseCsv)(file), header = _b[0], rows = _b.slice(1);
+    for (var _i = 0, rows_1 = rows; _i < rows_1.length; _i++) {
+        var row = rows_1[_i];
+        var data = {};
+        for (var index = 0; index < header.length && index < row.length; index++) {
+            data[header[index]] = row[index];
+        }
+        entities.push(new subClass(data, {}));
+    }
+    return new entities_1.Entities(entities, indexField);
+}
+exports.loadData = loadData;

package/lib/catalog/tables/author.d.ts

@@ -0,0 +1,4 @@
+import { Entity } from '../entity';
+export declare class Author extends Entity {
+    constructor(values: Record<string, string>);
+}

package/lib/catalog/tables/author.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Author = void 0;
+var value_1 = require("../value");
+var entity_1 = require("../entity");
+var Author = /** @class */ (function (_super) {
+    __extends(Author, _super);
+    function Author(values) {
+        return _super.call(this, values, {
+            name: { required: true, multiple: false },
+            qid: { required: false, multiple: false, format: value_1.FORMATS.QID },
+            main_full_name: { required: false, multiple: false },
+            full_names: { required: false, multiple: true }
+        }) || this;
+    }
+    return Author;
+}(entity_1.Entity));
+exports.Author = Author;

package/lib/catalog/tables/index.d.ts

@@ -0,0 +1,2 @@
+import { Entity } from '../entity';
+export declare const TYPE_INFO: Record<string, [typeof Entity, string]>;

package/lib/catalog/tables/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_INFO = void 0;
+var author_1 = require("./author");
+var publisher_1 = require("./publisher");
+var place_1 = require("./place");
+var work_1 = require("./work");
+exports.TYPE_INFO = {
+    authors: [author_1.Author, 'name'],
+    publishers: [publisher_1.Publisher, 'name'],
+    places: [place_1.Place, 'name'],
+    catalog: [work_1.Work, 'id']
+};

package/lib/catalog/tables/place.d.ts

@@ -0,0 +1,4 @@
+import { Entity } from '../entity';
+export declare class Place extends Entity {
+    constructor(values: Record<string, string>);
+}