adminforth 1.0.17 → 1.0.25

package/dist/spa_tmp/vite.config.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_url_1 = require("node:url");
+const vite_1 = require("vite");
+const plugin_vue_1 = __importDefault(require("@vitejs/plugin-vue"));
+const customLogger = {
+    info(msg) {
+        // Filter out the lines containing '➜ Local:' or '➜ Network:'
+        if (!msg.includes('➜')) {
+            console.log(msg);
+        }
+    },
+    warn(msg) {
+        console.warn(msg);
+    },
+    error(msg) {
+        console.error(msg);
+    },
+    clear() {
+        console.clear();
+    },
+    hasWarned: false,
+};
+// https://vitejs.dev/config/
+exports.default = (0, vite_1.defineConfig)({
+    base: process.env.VITE_ADMINFORTH_PUBLIC_PATH || '/',
+    server: {
+        port: 5173,
+        strictPort: true, // better predictability
+    },
+    customLogger,
+    plugins: [
+        (0, plugin_vue_1.default)(),
+    ],
+    resolve: {
+        alias: {
+            '@': (0, node_url_1.fileURLToPath)(new node_url_1.URL('./src', import.meta.url))
+        }
+    }
+});

package/dist/types.js

@@ -0,0 +1,30 @@
+// typical types which AdminForth supports
+//
+export const AdminForthTypes = {
+    STRING: 'string',
+    INTEGER: 'integer',
+    FLOAT: 'float',
+    DECIMAL: 'decimal',
+    BOOLEAN: 'boolean',
+    DATE: 'date',
+    DATETIME: 'datetime',
+    TIME: 'time',
+    TEXT: 'text',
+    JSON: 'json',
+};
+export const AdminForthFilterOperators = {
+    EQ: 'eq',
+    NE: 'ne',
+    GT: 'gt',
+    LT: 'lt',
+    GTE: 'gte',
+    LTE: 'lte',
+    LIKE: 'like',
+    ILIKE: 'ilike',
+    IN: 'in',
+    NIN: 'nin',
+};
+export const AdminForthSortDirections = {
+    ASC: 'asc',
+    DESC: 'desc',
+};

package/{index.js → index.ts}

@@ -10,13 +10,102 @@ import {v1 as uuid} from 'uuid';
 import fs from 'fs';
 
 
-import { AdminForthFilterOperators, AdminForthTypes } from './types.js';
+import { AdminForthFilterOperators, AdminForthTypes, AdminForthTypesValues } from './types.js';
 
 const AVAILABLE_SHOW_IN = ['list', 'edit', 'create', 'filter', 'show'];
 
+type AdminForthConfigMenuItem = {
+  label: string,
+  icon?: string,
+  path?: string,
+  component?: string,
+  resourceId?: string,
+  homepage?: boolean,
+  children?: Array<AdminForthConfigMenuItem>,
+}
+
+type AdminForthResourceColumn = {
+  name: string,
+  label?: string,
+  type?: AdminForthTypesValues,
+  primaryKey?: boolean,
+  required?: boolean | { create: boolean, edit: boolean },
+  editingNote?: string | { create: string, edit: string },
+  showIn?: Array<string>,
+  fillOnCreate?: Function,
+  isUnique?: boolean,
+  virtual?: boolean,
+  allowMinMaxQuery?: boolean,
+}
+
+type AdminForthResource = {
+  resourceId: string,
+  label?: string,
+  table: string,
+  dataSource: string,
+  columns: Array<AdminForthResourceColumn>,
+  itemLabel?: Function,
+  hooks?: {
+    show?: Function,
+    create?: {
+      beforeSave?: Function,
+      afterSave?: Function,
+    },
+    edit?: {
+      beforeSave?: Function,
+      afterSave?: Function,
+    },
+    delete?: {
+      beforeSave?: Function,
+      afterSave?: Function,
+    },
+  },
+  options?: {
+    bulkActions?: Array<{
+      label: string,
+      state: string,
+      icon: string,
+      action: Function,
+    }>,
+    allowDelete?: boolean,
+  },
+}
+
+type AdminForthDataSource = {
+  id: string,
+  url: string,
+}
+
+type AdminForthConfig = {
+  rootUser?: {
+    username: string,
+    password: string,
+  },
+  auth?: {
+    resourceId: string,
+    usernameField: string,
+    passwordHashField: string,
+    loginBackgroundImage?: string,
+    userFullName?: string,
+  },
+  resources: Array<any>,
+  menu: Array<AdminForthConfigMenuItem>,
+  databaseConnectors?: any,
+  dataSources: Array<any>,
+  customization?: {
+    customComponentsDir?: string,
+    vueUsesFile?: string,
+  },
+  baseUrl?: string,
+  brandName?: string,
+  datesFormat?: string,
+  deleteConfirmation?: boolean,
+}
+
 class AdminForth {
   static Types = AdminForthTypes;
 
+
   static Utils = {
     generatePasswordHash: async (password) => {
       return await Auth.generatePasswordHash(password);
@@ -29,7 +118,21 @@ class AdminForth {
     
   }
 
-  constructor(config) {
+  config: AdminForthConfig;
+  express: ExpressServer;
+  auth: Auth;
+  codeInjector: CodeInjector;
+  connectors: any;
+  connectorClasses: any;
+  runningHotReload?: boolean;
+
+
+  statuses: {
+    dbDiscover?: 'running' | 'done',
+  }
+
+
+  constructor(config: AdminForthConfig) {
     this.config = {...this.#defaultConfig,...config};
     this.validateConfig();
     this.express = new ExpressServer(this);
@@ -106,6 +209,8 @@ class AdminForth {
         }
         res.columns.forEach((col) => {
           col.label = col.label || guessLabelFromName(col.name);
+          //define default sortable
+          if (!Object.keys(col).includes('sortable')) {col.sortable = true;}
           if (col.showIn && !Array.isArray(col.showIn)) {
             errors.push(`Resource "${res.resourceId}" column "${col.name}" showIn must be an array`);
           }
@@ -134,6 +239,8 @@ class AdminForth {
             }
           }
 
+
+
           const wrongShowIn = col.showIn && col.showIn.find((c) => !AVAILABLE_SHOW_IN.includes(c));
           if (wrongShowIn) {
             errors.push(`Resource "${res.resourceId}" column "${col.name}" has invalid showIn value "${wrongShowIn}", allowed values are ${AVAILABLE_SHOW_IN.join(', ')}`);
@@ -267,7 +374,7 @@ class AdminForth {
       if (!this.connectors[res.dataSource]) {
         throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}'`);
       }
-      const fieldTypes = await this.connectors[res.dataSource].discoverFields(res.table);
+      const fieldTypes = await this.connectors[res.dataSource].discoverFields(res);
       if (!Object.keys(fieldTypes).length) {
         throw new Error(`Table '${res.table}' (In resource '${res.resourceId}') has no fields or does not exist`);
       }
@@ -312,6 +419,7 @@ class AdminForth {
       method: 'POST',
       path: '/login',
       handler: async ({ body, response }) => {
+        const INVALID_MESSAGE = 'Invalid username or password';
         const { username, password } = body;
         let token;
         if (username === this.config.rootUser.username && password === this.config.rootUser.password) {
@@ -496,7 +604,7 @@ class AdminForth {
         const item = await this.connectors[resource.dataSource].getMinMaxForColumns({
           resource,
           columns: resource.columns.filter((col) => [
-            AdminForthTypes.INT, 
+            AdminForthTypes.INTEGER, 
             AdminForthTypes.FLOAT,
             AdminForthTypes.DATE,
             AdminForthTypes.DATETIME,
@@ -510,7 +618,7 @@ class AdminForth {
     server.endpoint({
         method: 'POST',
         path: '/get_record',
-        handler: async ({ body }) => {
+        handler: async ({ body, adminUser }) => {
             const { resourceId, primaryKey } = body;
             const resource = this.config.resources.find((res) => res.resourceId == resourceId);
             const primaryKeyColumn = resource.columns.find((col) => col.primaryKey);
@@ -675,8 +783,9 @@ class AdminForth {
         noAuth: true, // TODO
         method: 'POST',
         path: '/delete_record',
-        handler: async ({ body }) => {
+        handler: async ({ body, adminUser }) => {
             const resource = this.config.resources.find((res) => res.resourceId == body['resourceId']);
+            const record = await this.connectors[resource.dataSource].getRecordByPrimaryKey(resource, body['primaryKey']);
             if (!resource) {
                 return { error: `Resource '${body['resourceId']}' not found` };
             }

package/modules/{codeInjector.js → codeInjector.ts}

@@ -7,6 +7,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
 import os from 'os';
+import AdminForth from '../index.js';
 
 
 const __filename = fileURLToPath(import.meta.url);
@@ -30,18 +31,21 @@ function hashify(obj) {
 
 class CodeInjector {
 
+  adminforth: AdminForth;
+
   static SPA_TMP_PATH = path.join(TMP_DIR, 'adminforth', 'spa_tmp');
 
   constructor(adminforth) {
     this.adminforth = adminforth;
   }
 
-  async runShell({command, verbose = false}) {
-    console.time(`Running ${command}...`);
-    const { stdout: out, stderr: err } = await execAsync(command);
-    console.timeEnd(`Running ${command}...`);
-    console.log(`Command ${command} output:`, out, err);
-  }
+  // async runShell({command, verbose = false}) {
+  //   console.log(`⚙️ Running shell ${command}...`);
+  //   console.time(`${command} done in`);
+  //   const { stdout: out, stderr: err } = await execAsync(command);
+  //   console.timeEnd(`${command} done in`);
+  //   console.log(`Command ${command} output:`, out, err);
+  // }
 
   async runNpmShell({command, verbose = false, cwd}) {
     const nodeBinary = process.execPath; // Path to the Node.js binary running this script
@@ -53,12 +57,13 @@ class CodeInjector {
       ...process.env,
     };
 
-    console.time(`Running npm ${command}...`);
+    console.log(`⚙️ Running npm ${command}...`);
+    console.time(`npm ${command} done in`);
     const { stdout: out, stderr: err } = await execAsync(`${nodeBinary} ${npmPath} ${command}`, {
       cwd,
       env,
     });
-    console.timeEnd(`Running npm ${command}...`);
+    console.timeEnd(`npm ${command} done in`);
 
     if (verbose) {
       console.log(`npm ${command} output:`, out);
@@ -78,7 +83,7 @@ class CodeInjector {
     }
   }
 
-  async prepareSources({ filesUpdated, verbose = false }) {
+  async prepareSources({ filesUpdated, verbose = false }: { filesUpdated?: string[], verbose?: boolean }) {
     const spaTmpPath = CodeInjector.SPA_TMP_PATH;
     // check SPA_TMP_PATH exists and create if not
     try {
@@ -122,10 +127,22 @@ class CodeInjector {
         const src = path.join(__dirname, 'spa', file);
         const dest = path.join(spaTmpPath, file);
         await fsExtra.copy(src, dest);
+        if (process.env.HEAVY_DEBUG) {
+          console.log('🪲 await fsExtra.copy filtering', src, dest);
+        }
+
       }));
     } else {
+      if (process.env.HEAVY_DEBUG) {
+        console.log(`🪲 await fsExtra.copy from ${path.join(__dirname, 'spa')}, ${spaTmpPath}`);
+      }
+
       await fsExtra.copy(path.join(__dirname, 'spa'), spaTmpPath, {
         filter: (src) => {
+          if (process.env.HEAVY_DEBUG) {
+            console.log('🪲 await fsExtra.copy filtering', src);
+          }
+
           return !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist');
         },
       });
@@ -338,8 +355,8 @@ async watchForReprepare({ verbose }) {
     });
   }
 
-  async bundleNow({hotReload = false, verbose = false}) {
-    this.adminforth.config.runningHotReload = hotReload;
+  async bundleNow({hotReload = false, verbose = false}: {hotReload: boolean, verbose: boolean}) {
+    this.adminforth.runningHotReload = hotReload;
 
     await this.prepareSources({ verbose });
 
@@ -357,7 +374,7 @@ async watchForReprepare({ verbose }) {
       await this.runNpmShell({command: 'run build-only', verbose, cwd});
     } else {
       const command = 'run dev';
-      console.time(`Running npm ${command}...`);
+      console.log(`⚙️ Running npm ${command}...`);
       const nodeBinary = process.execPath; 
       const npmPath = path.join(path.dirname(nodeBinary), 'npm');
       const env = {
@@ -380,7 +397,6 @@ async watchForReprepare({ verbose }) {
 
       });
 
-      console.timeEnd(`Running npm ${command}...`);
     }
   }
 }

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "adminforth",
-  "version": "1.0.17",
+  "version": "1.0.25",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "rollout": "tsc && npm version patch  && npm publish"
   },
   "author": "devforth.io",
   "license": "ISC",
@@ -19,5 +22,8 @@
     "mongodb": "6.6",
     "pg": "^8.11.5",
     "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.5"
   }
 }

package/servers/{express.js → express.ts}

@@ -3,6 +3,8 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
 import CodeInjector from '../modules/codeInjector.js';
+import AdminForth from '../index.js';
+import { Express } from 'express';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -81,6 +83,10 @@ const respondNoServer = (title, explanation) => {
     `;
 }
 class ExpressServer {
+
+  expressApp: Express;
+  adminforth: AdminForth;
+
   constructor(adminforth) {
     this.adminforth = adminforth;
   }
@@ -90,7 +96,7 @@ class ExpressServer {
 
     const slashedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`;
 
-    if (this.adminforth.config.runningHotReload) {
+    if (this.adminforth.runningHotReload) {
       const handler = async (req, res) => {
         // proxy using fetch to webpack dev server
         try {
@@ -98,7 +104,7 @@ class ExpressServer {
         } catch (e) {
           res.status(500).send(respondNoServer('AdminForth SPA is not ready yet', 'Vite is still starting up. Please wait a moment...'));
           return;
-        }
+      }
       }
       this.expressApp.get(`${slashedPrefix}assets/*`, handler);
       this.expressApp.get(`${prefix}*`, handler);

package/spa/package.json

@@ -4,8 +4,8 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "NODE_PATH=./node_modules/ vite",
-    "build": "NODE_PATH=./node_modules/ run-p type-check \"build-only {@}\" --",
+    "dev": "vite",
+    "build": "run-p type-check \"build-only {@}\" --",
     "preview": "vite preview",
     "build-only": "vite build",
     "type-check": "vue-tsc --build --force",

package/spa/src/views/ListView.vue

@@ -101,7 +101,7 @@
           </th>
 
           <th v-for="c in columnsListed" scope="col" class="px-6 py-3">
-            <div @click="() => c.sortable && onSortButtonClick(c.name)" class="flex items-center cursor-pointer">
+            <div @click="() => c.sortable && onSortButtonClick(c.name)" class="flex items-center " :class="{'cursor-pointer':c.sortable}">
               {{ c.label }}
 
               <div v-if="c.sortable"

package/tsconfig.json

@@ -0,0 +1,112 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    // changed from commmonjs to node16 because The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'.
+    "module": "node16",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": false,   /* TODO */                                   /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
+  },
+  "exclude": ["node_modules", "dist", "spa"],           /* Exclude files from compilation. */
+}

package/{types.js → types.ts}

@@ -15,6 +15,8 @@ export const AdminForthTypes = {
   JSON: 'json',
 }
 
+export type AdminForthTypesValues = keyof typeof AdminForthTypes;
+
 export const AdminForthFilterOperators = {
   EQ: 'eq',
   NE: 'ne',