ng-tablekit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TableKit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PUBLISHING.md

@@ -0,0 +1,46 @@
+# Publishing ng-tablekit
+
+The package is configured for public npm distribution as `ng-tablekit`.
+
+## Release checklist
+
+1. Confirm that the package name is still available:
+
+   ```bash
+   npm view ng-tablekit
+   ```
+
+   A `404 Not Found` response means no package currently uses the name. Availability is not reserved until the first successful publish.
+
+2. Sign in to npmjs.com, open **Account → Two-Factor Authentication**, and add
+   a WebAuthn security key or passkey. New TOTP enrollment is no longer
+   supported. Windows Hello can be used as the passkey on Windows.
+
+   Save the recovery codes somewhere secure, then refresh the CLI session:
+
+   ```bash
+   npm login
+   npm whoami
+   ```
+
+3. Run all publication checks:
+
+   ```bash
+   npm run release:check
+   npm run test:package
+   npm pack --dry-run
+   ```
+
+4. Publish the first public release:
+
+   ```bash
+   npm publish --access public
+   ```
+
+5. Verify the public command from a clean Angular 19 workspace:
+
+   ```bash
+   npx ng-tablekit@latest add report-page
+   ```
+
+For later releases, update the version with `npm version patch`, `minor`, or `major` before publishing. Never reuse an npm version that has already been published.

package/README.md

@@ -0,0 +1,102 @@
+# ng-tablekit
+
+A cross-platform CLI that adds ready-to-use Angular 19 and NG-ZORRO 19 table pages to an existing Angular workspace.
+
+## Requirements
+
+- Node.js 18.19 or newer
+- An Angular 19 workspace
+- npm, pnpm, Yarn, or Bun
+
+The CLI runs on Windows, macOS, and Linux. It detects the nearest Angular workspace, so you can run it from the workspace root or any folder below it.
+
+## Quick start
+
+Add a report page with filter, Excel export, PDF export, global search, sorting, and pagination:
+
+```bash
+npx ng-tablekit@latest add report-page
+```
+
+Or add a master page with global search, Add/Edit drawers, row actions, role mapping, sorting, and pagination:
+
+```bash
+npx ng-tablekit@latest add master-page
+```
+
+Then start the Angular application and open `/report-page` or `/master-page`.
+
+The CLI automatically:
+
+- copies the selected page and its shared runtime files;
+- installs only missing page dependencies;
+- configures the NG-ZORRO stylesheet and Angular animations;
+- adds a lazy route to `src/app/app.routes.ts`;
+- uses relative imports, so no TypeScript path aliases are required;
+- preserves existing files and stops before overwriting changed content.
+
+## Commands
+
+```bash
+npx ng-tablekit@latest list
+npx ng-tablekit@latest --help
+npx ng-tablekit@latest --version
+```
+
+Options for `add`:
+
+```text
+--project <directory>  Angular workspace root (normally auto-detected)
+--path <directory>     Custom destination inside the workspace
+--route <path>         Custom route path
+--skip-route           Do not edit app.routes.ts
+--skip-install         Update package.json without installing dependencies
+--force                Replace conflicting generated files
+```
+
+Example with a custom destination and route:
+
+```bash
+npx ng-tablekit@latest add master-page --path src/app/admin/users --route users
+```
+
+## Optional project installation
+
+To pin a CLI version for a team, install it as a development dependency:
+
+```bash
+npm install --save-dev ng-tablekit
+npx tablekit add report-page
+```
+
+The `tablekit` executable is included as a convenient alias when the package is installed locally.
+
+## Safe updates
+
+Running the same command again is safe when generated files still match. If any target file has different content, the CLI stops and lists the conflicts. Use `--force` only when replacing those files is intentional.
+
+## Column configuration
+
+Columns opt in to sorting. A sorting icon and sort behavior are included only when `sortable: true` is present.
+
+```ts
+columns = [
+  { key: 'name', title: 'Name', sortable: true },
+  { key: 'department', title: 'Department' },
+  { key: 'status', title: 'Status', sortable: false, type: 'status' }
+];
+```
+
+Adding, removing, or reordering configured columns does not require table markup changes.
+
+## Develop this package
+
+```bash
+npm install
+npm run test:cli
+npm run test:package
+npm run verify:static
+npm run build
+```
+
+Release instructions are in [PUBLISHING.md](PUBLISHING.md).

package/bin/tablekit.mjs

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import {
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+  sep
+} from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const cliPackage = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+const cliVersion = cliPackage.version;
+const commonSourceRoot = join(packageRoot, 'src', 'app', 'core');
+const commonFiles = [
+  'models/table.models.ts',
+  'config/table.config.ts',
+  'data/record.data.ts',
+  'utils/table.utils.ts'
+];
+
+const templates = {
+  'report-page': {
+    className: 'ReportPageComponent',
+    componentFile: 'report-page.component',
+    files: [
+      'report-page.component.html',
+      'report-page.component.css',
+      'report-page.component.ts'
+    ],
+    dependencies: {
+      '@ant-design/icons-angular': '^19.0.0',
+      'ng-zorro-antd': '^19.0.0',
+      'jspdf': '^3.0.4',
+      'xlsx': '^0.18.5'
+    }
+  },
+  'master-page': {
+    className: 'MasterPageComponent',
+    componentFile: 'master-page.component',
+    files: [
+      'master-page.component.html',
+      'master-page.component.css',
+      'master-page.component.ts',
+      'master-record-drawer.component.html',
+      'master-record-drawer.component.css',
+      'master-record-drawer.component.ts',
+      'master-map-drawer.component.html',
+      'master-map-drawer.component.css',
+      'master-map-drawer.component.ts'
+    ],
+    dependencies: {
+      '@ant-design/icons-angular': '^19.0.0',
+      'ng-zorro-antd': '^19.0.0',
+      'jspdf': '^3.0.4',
+      'xlsx': '^0.18.5'
+    }
+  }
+};
+
+function printHelp() {
+  console.log(`TableKit CLI
+
+Usage:
+  npx ng-tablekit@latest list
+  npx ng-tablekit@latest add <report-page|master-page> [options]
+
+Options:
+  --project <directory>  Angular workspace root (default: nearest parent workspace)
+  --path <directory>     Destination relative to the workspace
+                         (default: src/app/pages/<template>)
+  --route <path>         Route path (default: template name)
+  --skip-route           Do not update src/app/app.routes.ts
+  --skip-install         Update package.json without running the package manager
+  --force                Replace conflicting generated files
+  -v, --version          Show the installed CLI version
+  -h, --help             Show this help
+
+Examples:
+  npx ng-tablekit@latest add report-page
+  npx ng-tablekit@latest add master-page --path src/app/admin/master-page
+  npx ng-tablekit@latest add report-page --skip-install
+`);
+}
+
+function fail(message) {
+  console.error(`\nTableKit: ${message}`);
+  process.exitCode = 1;
+}
+
+function parseArguments(argv) {
+  const options = {
+    command: argv[0],
+    templateName: argv[1],
+    project: null,
+    destination: null,
+    route: null,
+    skipRoute: false,
+    skipInstall: false,
+    force: false,
+    version: false,
+    help: false
+  };
+
+  if (argv.includes('--help') || argv.includes('-h')) options.help = true;
+  if (argv.includes('--version') || argv.includes('-v')) options.version = true;
+
+  for (let index = 2; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--project' || argument === '--path' || argument === '--route') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) throw new Error(`${argument} requires a value.`);
+      if (argument === '--project') options.project = value;
+      if (argument === '--path') options.destination = value;
+      if (argument === '--route') options.route = value;
+      index += 1;
+    } else if (argument === '--skip-route') {
+      options.skipRoute = true;
+    } else if (argument === '--skip-install') {
+      options.skipInstall = true;
+    } else if (argument === '--force') {
+      options.force = true;
+    } else if (argument === '--version' || argument === '-v') {
+      options.version = true;
+    } else if (argument === '--help' || argument === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown option: ${argument}`);
+    }
+  }
+
+  return options;
+}
+
+function readJson(path, label) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (error) {
+    throw new Error(`Could not read ${label} at ${path}: ${error.message}`);
+  }
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function toImportPath(fromDirectory, targetWithoutExtension) {
+  let importPath = relative(fromDirectory, targetWithoutExtension).split(sep).join('/');
+  if (!importPath.startsWith('.')) importPath = `./${importPath}`;
+  return importPath;
+}
+
+function isInside(parent, child) {
+  const value = relative(parent, child);
+  return value === '' || (!value.startsWith(`..${sep}`) && value !== '..' && !isAbsolute(value));
+}
+
+function findWorkspaceRoot(startDirectory) {
+  let current = resolve(startDirectory);
+  while (true) {
+    if (existsSync(join(current, 'angular.json')) && existsSync(join(current, 'package.json'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function stripCatalogueCode(source, extension) {
+  let result = source;
+  if (extension === '.html') {
+    result = result.replace(/^\s*<div class="template-code-actions">[\s\S]*?<\/div>\s*/i, '');
+  }
+  if (extension === '.ts') {
+    result = result.replace(/import\s+{\s*CopyTemplateButtonComponent\s*}\s+from\s+['"][^'"]+['"];?\s*/g, '');
+    result = result.replace(/,\s*CopyTemplateButtonComponent\b/g, '');
+    result = result.replace(/\bCopyTemplateButtonComponent\s*,\s*/g, '');
+  }
+  return result;
+}
+
+function prepareFiles(projectRoot, destinationRoot, templateName, force) {
+  const definition = templates[templateName];
+  const templateSourceRoot = join(packageRoot, 'src', 'app', 'templates', templateName);
+  const commonDestinationRoot = join(projectRoot, 'src', 'app', 'tablekit');
+  const operations = [];
+
+  for (const file of commonFiles) {
+    operations.push({
+      path: join(commonDestinationRoot, file),
+      content: readFileSync(join(commonSourceRoot, file), 'utf8')
+    });
+  }
+
+  for (const file of definition.files) {
+    const destinationPath = join(destinationRoot, file);
+    const extension = file.endsWith('.html') ? '.html' : file.endsWith('.css') ? '.css' : '.ts';
+    let content = readFileSync(join(templateSourceRoot, file), 'utf8');
+    content = stripCatalogueCode(content, extension);
+
+    if (extension === '.ts') {
+      content = content.replace(/@core\/([^'"]+)/g, (_match, corePath) => {
+        return toImportPath(dirname(destinationPath), join(commonDestinationRoot, corePath));
+      });
+    }
+    operations.push({ path: destinationPath, content });
+  }
+
+  const conflicts = operations.filter(operation => {
+    return existsSync(operation.path) && readFileSync(operation.path, 'utf8') !== operation.content;
+  });
+  if (conflicts.length > 0 && !force) {
+    const paths = conflicts.map(conflict => `  - ${relative(projectRoot, conflict.path)}`).join('\n');
+    throw new Error(`These files already exist with different content:\n${paths}\nRun again with --force to replace them.`);
+  }
+
+  for (const operation of operations) {
+    mkdirSync(dirname(operation.path), { recursive: true });
+    if (!existsSync(operation.path) || force || readFileSync(operation.path, 'utf8') !== operation.content) {
+      writeFileSync(operation.path, operation.content, 'utf8');
+    }
+  }
+
+  return definition;
+}
+
+function updatePackageJson(projectRoot, definition) {
+  const packagePath = join(projectRoot, 'package.json');
+  const packageJson = readJson(packagePath, 'package.json');
+  packageJson.dependencies ??= {};
+  const added = [];
+
+  const angularVersion = packageJson.dependencies['@angular/core'] ?? packageJson.devDependencies?.['@angular/core'];
+  const required = { ...definition.dependencies };
+  if (angularVersion && !packageJson.dependencies['@angular/animations'] && !packageJson.devDependencies?.['@angular/animations']) {
+    required['@angular/animations'] = angularVersion;
+  }
+
+  for (const [name, version] of Object.entries(required)) {
+    if (!packageJson.dependencies[name] && !packageJson.devDependencies?.[name]) {
+      packageJson.dependencies[name] = version;
+      added.push(name);
+    }
+  }
+
+  packageJson.dependencies = Object.fromEntries(Object.entries(packageJson.dependencies).sort(([left], [right]) => left.localeCompare(right)));
+  if (added.length > 0) writeJson(packagePath, packageJson);
+  return added;
+}
+
+function validateAngularWorkspace(projectRoot) {
+  const packageJson = readJson(join(projectRoot, 'package.json'), 'package.json');
+  const angularVersion = packageJson.dependencies?.['@angular/core'] ?? packageJson.devDependencies?.['@angular/core'];
+  if (!angularVersion) throw new Error('The target project does not declare @angular/core.');
+  const angularMajor = String(angularVersion).match(/\d+/)?.[0];
+  if (angularMajor !== '19') {
+    throw new Error(`This TableKit release supports Angular 19; the target declares @angular/core ${angularVersion}.`);
+  }
+
+  const zorroVersion = packageJson.dependencies?.['ng-zorro-antd'] ?? packageJson.devDependencies?.['ng-zorro-antd'];
+  const zorroMajor = zorroVersion ? String(zorroVersion).match(/\d+/)?.[0] : null;
+  if (zorroMajor && zorroMajor !== '19') {
+    throw new Error(`The target declares ng-zorro-antd ${zorroVersion}; version 19 is required.`);
+  }
+}
+
+function updateAngularStyles(projectRoot) {
+  const angularPath = join(projectRoot, 'angular.json');
+  const angularJson = readJson(angularPath, 'angular.json');
+  const projects = Object.values(angularJson.projects ?? {});
+  const application = projects.find(project => project.projectType === 'application') ?? projects[0];
+  const styles = application?.architect?.build?.options?.styles ?? application?.targets?.build?.options?.styles;
+  if (!Array.isArray(styles)) return false;
+
+  const zorroStyle = 'node_modules/ng-zorro-antd/ng-zorro-antd.min.css';
+  const hasStyle = styles.some(style => {
+    const stylePath = typeof style === 'string' ? style : style?.input;
+    if (stylePath === zorroStyle) return true;
+    if (!stylePath) return false;
+    const localStylePath = resolve(projectRoot, stylePath);
+    return existsSync(localStylePath) && readFileSync(localStylePath, 'utf8').includes('ng-zorro-antd');
+  });
+  if (!hasStyle) {
+    styles.unshift(zorroStyle);
+    writeJson(angularPath, angularJson);
+  }
+  return true;
+}
+
+function updateAnimations(projectRoot) {
+  const configPath = join(projectRoot, 'src', 'app', 'app.config.ts');
+  if (!existsSync(configPath)) return false;
+
+  let content = readFileSync(configPath, 'utf8');
+  if (/provideAnimations(?:Async)?\s*\(/.test(content)) return true;
+  const newline = content.includes('\r\n') ? '\r\n' : '\n';
+  const coreImport = /import[^\n]+from ['"]@angular\/core['"];?\r?\n/;
+  if (!coreImport.test(content) || !/providers\s*:\s*\[/.test(content)) return false;
+
+  content = content.replace(coreImport, match => `${match}import { provideAnimations } from '@angular/platform-browser/animations';${newline}`);
+  content = content.replace(/providers\s*:\s*\[/, `providers: [${newline}    provideAnimations(),`);
+  writeFileSync(configPath, content, 'utf8');
+  return true;
+}
+
+function updateRoutes(projectRoot, destinationRoot, routePath, definition) {
+  const routesPath = join(projectRoot, 'src', 'app', 'app.routes.ts');
+  if (!existsSync(routesPath)) return false;
+
+  let content = readFileSync(routesPath, 'utf8');
+  const escapedRoute = routePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const existingRoute = new RegExp(`^\\s*{\\s*path\\s*:\\s*['"]${escapedRoute}['"]`, 'm').exec(content);
+  if (existingRoute) {
+    const beforeRoute = content.slice(0, existingRoute.index);
+    const previousTokenIndex = beforeRoute.search(/\S(?=\s*$)/);
+    if (previousTokenIndex >= 0 && beforeRoute[previousTokenIndex] === '}') {
+      content = `${beforeRoute.slice(0, previousTokenIndex + 1)},${beforeRoute.slice(previousTokenIndex + 1)}${content.slice(existingRoute.index)}`;
+      writeFileSync(routesPath, content, 'utf8');
+    }
+    return true;
+  }
+
+  const componentFile = join(destinationRoot, definition.componentFile);
+  const importPath = toImportPath(dirname(routesPath), componentFile);
+  const routeLine = `  { path: '${routePath}', loadComponent: () => import('${importPath}').then(m => m.${definition.className}) },`;
+  const wildcard = /^(\s*){\s*path\s*:\s*['"]\*\*['"]/m;
+  if (wildcard.test(content)) {
+    content = content.replace(wildcard, `${routeLine}\n$&`);
+  } else {
+    const arrayEnd = content.lastIndexOf('];');
+    if (arrayEnd < 0) return false;
+    let beforeArrayEnd = content.slice(0, arrayEnd);
+    const previousTokenIndex = beforeArrayEnd.search(/\S(?=\s*$)/);
+    if (previousTokenIndex >= 0 && beforeArrayEnd[previousTokenIndex] === '}') {
+      beforeArrayEnd = `${beforeArrayEnd.slice(0, previousTokenIndex + 1)},${beforeArrayEnd.slice(previousTokenIndex + 1)}`;
+    }
+    content = `${beforeArrayEnd}${routeLine}\n${content.slice(arrayEnd)}`;
+  }
+  writeFileSync(routesPath, content, 'utf8');
+  return true;
+}
+
+function detectPackageManager(projectRoot) {
+  if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) return { command: 'pnpm', args: ['install'] };
+  if (existsSync(join(projectRoot, 'yarn.lock'))) return { command: 'yarn', args: ['install'] };
+  if (existsSync(join(projectRoot, 'bun.lockb')) || existsSync(join(projectRoot, 'bun.lock'))) return { command: 'bun', args: ['install'] };
+  return { command: 'npm', args: ['install'] };
+}
+
+function installDependencies(projectRoot) {
+  const manager = detectPackageManager(projectRoot);
+  console.log(`\nInstalling dependencies with ${manager.command}...`);
+  const result = spawnSync(manager.command, manager.args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    shell: process.platform === 'win32'
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`${manager.command} install exited with code ${result.status}.`);
+}
+
+function addTemplate(options) {
+  const templateName = options.templateName;
+  if (!templateName || !templates[templateName]) {
+    const oldNameHint = templateName === 'report-with-pdf'
+      ? ' Use report-page instead.'
+      : templateName === 'master-listing'
+        ? ' Use master-page instead.'
+        : '';
+    throw new Error(`Choose report-page or master-page.${oldNameHint}`);
+  }
+
+  const projectRoot = options.project ? resolve(options.project) : findWorkspaceRoot(process.cwd());
+  if (!projectRoot) {
+    throw new Error('Could not find an Angular workspace in the current directory or its parents. Use --project <directory>.');
+  }
+  if (!existsSync(join(projectRoot, 'angular.json')) || !existsSync(join(projectRoot, 'package.json'))) {
+    throw new Error(`${projectRoot} is not an Angular workspace.`);
+  }
+  validateAngularWorkspace(projectRoot);
+
+  const destinationRoot = resolve(projectRoot, options.destination ?? join('src', 'app', 'pages', templateName));
+  if (!isInside(projectRoot, destinationRoot)) throw new Error('The destination must stay inside the Angular workspace.');
+
+  const routePath = (options.route ?? templateName).replace(/^\/+|\/+$/g, '');
+  if (!routePath || !/^[a-z0-9][a-z0-9-]*$/.test(routePath)) {
+    throw new Error('The route must contain lowercase letters, numbers, or hyphens.');
+  }
+
+  console.log(`\nAdding ${templateName} to ${relative(projectRoot, destinationRoot)}...`);
+  const definition = prepareFiles(projectRoot, destinationRoot, templateName, options.force);
+  const addedDependencies = updatePackageJson(projectRoot, definition);
+  const stylesUpdated = updateAngularStyles(projectRoot);
+  const animationsUpdated = updateAnimations(projectRoot);
+  const routeUpdated = options.skipRoute ? true : updateRoutes(projectRoot, destinationRoot, routePath, definition);
+
+  if (addedDependencies.length > 0 && !options.skipInstall) installDependencies(projectRoot);
+
+  console.log(`\n✓ Added ${templateName}`);
+  console.log(`✓ Page files: ${relative(projectRoot, destinationRoot)}`);
+  console.log('✓ Shared runtime: src/app/tablekit');
+  console.log(options.skipRoute ? '– Route update skipped' : routeUpdated ? `✓ Route: /${routePath}` : '⚠ Could not update app.routes.ts; add the route manually.');
+  console.log(stylesUpdated ? '✓ NG-ZORRO stylesheet configured' : '⚠ Could not find the Angular build styles array.');
+  console.log(animationsUpdated ? '✓ Angular animations configured' : '⚠ Could not update app.config.ts; ensure animations are provided.');
+  if (addedDependencies.length === 0) {
+    console.log('✓ Required dependencies already present');
+  } else if (options.skipInstall) {
+    console.log(`✓ Added dependencies to package.json: ${addedDependencies.join(', ')}`);
+    console.log('  Run your package manager install command before starting the app.');
+  }
+}
+
+try {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.version) {
+    console.log(cliVersion);
+  } else if (options.help || !options.command) {
+    printHelp();
+  } else if (options.command === 'list') {
+    console.log('Available templates:\n  report-page\n  master-page');
+  } else if (options.command === 'add') {
+    addTemplate(options);
+  } else {
+    throw new Error(`Unknown command: ${options.command}`);
+  }
+} catch (error) {
+  fail(error.message);
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "ng-tablekit",
+  "version": "1.0.0",
+  "description": "Cross-platform CLI for adding Angular 19 and NG-ZORRO report and master table pages.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "angular",
+    "angular-19",
+    "ng-zorro",
+    "table",
+    "report",
+    "cli",
+    "scaffold"
+  ],
+  "bin": {
+    "ng-tablekit": "bin/tablekit.mjs",
+    "tablekit": "bin/tablekit.mjs"
+  },
+  "files": [
+    "bin",
+    "src/app/core/config/table.config.ts",
+    "src/app/core/data/record.data.ts",
+    "src/app/core/models/table.models.ts",
+    "src/app/core/utils/table.utils.ts",
+    "src/app/templates/report-page",
+    "src/app/templates/master-page",
+    "README.md",
+    "LICENSE",
+    "PUBLISHING.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.19"
+  },
+  "scripts": {
+    "ng": "ng",
+    "start": "ng serve",
+    "build": "ng build --configuration production",
+    "test": "ng test --watch=false --browsers=ChromeHeadless",
+    "e2e": "playwright test",
+    "verify:static": "node scripts/verify-project.mjs",
+    "tablekit": "node ./bin/tablekit.mjs",
+    "test:cli": "node --test tests/tablekit-cli.test.mjs",
+    "test:package": "node --test tests/tablekit-package.test.mjs",
+    "release:check": "node scripts/release-check.mjs",
+    "prepack": "npm run release:check"
+  },
+  "devDependencies": {
+    "@angular/animations": "19.2.25",
+    "@angular/cdk": "19.2.19",
+    "@angular/common": "19.2.25",
+    "@angular/compiler": "19.2.25",
+    "@angular/compiler-cli": "19.2.25",
+    "@angular/core": "19.2.25",
+    "@angular/forms": "19.2.25",
+    "@angular/platform-browser": "19.2.25",
+    "@angular/platform-browser-dynamic": "19.2.25",
+    "@angular/router": "19.2.25",
+    "@angular-devkit/build-angular": "19.2.27",
+    "@angular/cli": "19.2.27",
+    "@ant-design/icons-angular": "19.0.0",
+    "@playwright/test": "^1.55.0",
+    "@types/jasmine": "~5.1.5",
+    "jasmine-core": "~5.6.0",
+    "jspdf": "^3.0.4",
+    "karma": "~6.4.4",
+    "karma-chrome-launcher": "~3.2.0",
+    "karma-coverage": "~2.2.1",
+    "karma-jasmine": "~5.1.0",
+    "karma-jasmine-html-reporter": "~2.1.0",
+    "ng-zorro-antd": "19.2.0",
+    "rxjs": "~7.8.2",
+    "tslib": "^2.8.1",
+    "typescript": "~5.7.3",
+    "xlsx": "^0.18.5",
+    "zone.js": "~0.15.0"
+  }
+}