@unifylib/ui-lib 1.0.64 → 1.0.66

package/cli/generators/table-screen.js

@@ -0,0 +1,181 @@
+"use strict";
+
+/**
+ * @param {{
+ *  kebab: string,
+ *  pascal: string,
+ *  labelsSection: string,
+ *  apiUri: string,
+ *  importPath: string,
+ * }} ctx
+ */
+function generate(ctx) {
+  const fileBase = ctx.kebab;
+
+  const settings = `import { Validators } from "@angular/forms";
+import {
+  ButtonActionSettings,
+  FieldInfo,
+  FilterRequest,
+  PageInfo,
+  ReportRequest,
+  TableColumn,
+} from "${ctx.importPath}";
+
+export const PAGE_INFO: PageInfo = {
+  id: "${ctx.kebab}",
+  labelsSection: "${ctx.labelsSection}",
+  hasAddButton: true,
+  apiUri: "${ctx.apiUri}",
+  selfRouting: true,
+  listRoutePath: "/${ctx.kebab}",
+  draftSupported: true,
+  pageSize: 10,
+};
+
+export const COLUMNS: TableColumn<Record<string, unknown>>[] = [
+  { property: "id", type: "text", enableSorting: true, visible: true, label: "id" },
+  { property: "name", type: "text", enableSorting: true, visible: true, label: "name" },
+];
+
+export const FILTER_FIELDS: FieldInfo[] = [
+  new FieldInfo({
+    property: "name",
+    row: 1,
+    type: "text",
+    label: "name",
+    advancedFilter: true,
+    filterOperator: "LIKE",
+    validators: [Validators.maxLength(30)],
+    maxLength: 30,
+  } as FieldInfo),
+];
+
+function buildReportRequest(): ReportRequest {
+  const filterRequest = new FilterRequest(PAGE_INFO.pageSize ?? 10);
+  filterRequest.columns = COLUMNS.filter((c) => c.visible !== false).map((c) => c.property);
+  return new ReportRequest({ filterRequest });
+}
+
+export const REPORT_REQUEST: ReportRequest = buildReportRequest();
+
+export const LIST_ACTIONS: ButtonActionSettings[] = [
+  new ButtonActionSettings({
+    key: 1,
+    id: "view",
+    label: "VIEW",
+    linkHref: (row: unknown) => {
+      const id = (row as { id?: number }).id;
+      return id != null ? \`/${ctx.kebab}/view/\${id}\` : undefined;
+    },
+  } as ButtonActionSettings),
+];
+
+export const TOOLBAR_ACTIONS: ButtonActionSettings[] = [
+  new ButtonActionSettings({
+    key: 1,
+    id: "create",
+    label: "ADD_NEW",
+    linkHref: "/${ctx.kebab}/new",
+  } as ButtonActionSettings),
+];
+`;
+
+  const componentTs = `import { ChangeDetectionStrategy, Component, inject } from "@angular/core";
+import { Router } from "@angular/router";
+import { TranslateModule } from "@ngx-translate/core";
+import {
+  BaseTableComponent,
+  ButtonActionSettings,
+  Filter,
+} from "${ctx.importPath}";
+import {
+  COLUMNS,
+  FILTER_FIELDS,
+  LIST_ACTIONS,
+  PAGE_INFO,
+  REPORT_REQUEST,
+  TOOLBAR_ACTIONS,
+} from "./${fileBase}.settings";
+
+@Component({
+  selector: "app-${fileBase}",
+  standalone: true,
+  imports: [BaseTableComponent, TranslateModule],
+  templateUrl: "./${fileBase}.component.html",
+  styleUrls: ["./${fileBase}.component.scss"],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class ${ctx.pascal}Component {
+  private readonly router = inject(Router);
+
+  readonly pageInfo = PAGE_INFO;
+  readonly columnsDefinition = COLUMNS;
+  readonly filterFieldDefinitions = FILTER_FIELDS;
+  readonly reportRequest = REPORT_REQUEST;
+  readonly filters: Filter[] = [];
+  readonly listActions = LIST_ACTIONS;
+  readonly toolbarActions = TOOLBAR_ACTIONS;
+  readonly isPending = false;
+
+  onListActionClicked(event: {
+    action: ButtonActionSettings;
+    row: unknown;
+    isPending: boolean;
+  }): void {
+    const href =
+      typeof event.action.linkHref === "function"
+        ? event.action.linkHref(event.row)
+        : event.action.linkHref;
+    if (href) {
+      void this.router.navigateByUrl(href);
+    }
+  }
+
+  onToolbarButton(action: ButtonActionSettings): void {
+    if (typeof action.linkHref === "string") {
+      void this.router.navigateByUrl(action.linkHref);
+    }
+  }
+}
+`;
+
+  const componentHtml = `<app-base-table
+  [pageInfo]="pageInfo"
+  [columns]="columnsDefinition"
+  [reportRequest]="reportRequest"
+  [filterFields]="filterFieldDefinitions"
+  [isPending]="isPending"
+  [filters]="filters"
+  [listAction]="listActions"
+  [extraActions]="toolbarActions"
+  [buttonsDisplayMode]="'list'"
+  (listActionClicked)="onListActionClicked($event)"
+  (buttonClicked)="onToolbarButton($event)">
+</app-base-table>
+`;
+
+  const componentScss = `:host {
+  display: block;
+}
+`;
+
+  return [
+    { relative: `${fileBase}.settings.ts`, content: settings },
+    { relative: `${fileBase}.component.ts`, content: componentTs },
+    { relative: `${fileBase}.component.html`, content: componentHtml },
+    { relative: `${fileBase}.component.scss`, content: componentScss },
+  ];
+}
+
+function getTranslations(ctx) {
+  return {
+    [`${ctx.labelsSection}.list_title`]: `${ctx.pascal} List`,
+    [`${ctx.labelsSection}.id`]: "ID",
+    [`${ctx.labelsSection}.name`]: "Name",
+    VIEW: "View",
+    ADD_NEW: "Add new",
+  };
+}
+
+module.exports = { generate, getTranslations };

package/cli/index.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+"use strict";
+
+const path = require("path");
+const {
+  kebabCase,
+  pascalCase,
+  upperSnakeFromKebab,
+  lastPathSegment,
+  writeFiles,
+  upsertI18nEntries,
+} = require("./utils");
+
+const GENERATORS = {
+  "form-screen": require("./generators/form-screen.js"),
+  "table-screen": require("./generators/table-screen.js"),
+  "section-form": require("./generators/section-form.js"),
+  "line-editor": require("./generators/line-editor.js"),
+  dashboard: require("./generators/dashboard.js"),
+  "permission-matrix": require("./generators/permission-matrix.js"),
+};
+
+function printHelp() {
+  console.log(`
+iq-ui — scaffold Angular screens that use @unifylib/ui-lib
+
+Usage:
+  iq-ui -g <type> <destination> [options]
+
+Types:
+  form-screen        app-base-form-canvas + settings
+  table-screen       app-base-table + settings
+  section-form       lib-section-form-canvas + settings
+  line-editor        app-item-line-editor + settings
+  dashboard          lib-action-card grid (no settings file)
+  permission-matrix  lib-permission-matrix + settings
+
+Options:
+  --name <n>              File/class base name (default: last segment of destination)
+  --labels-section <s>   i18n labelsSection (default: UPPER_SNAKE from name)
+  --api-uri <u>          API path for PageInfo.apiUri (default: /<name>)
+  --fields-count <n>     Placeholder fields (default: 6; form-screen, section-form, line-editor)
+  --import-path <p>      Library import (default: @iq/ui-lib)
+  --i18n-path <p>        Optional translation file/folder (example: src/assets/en.json or src/assets)
+  --dry-run              Print files that would be written
+  -h, --help             Show this help
+
+Examples (after npm install @unifylib/ui-lib, use the package binary; do not run \`npx iq-ui\`, which looks up a wrong package on npm):
+  npx -p @unifylib/ui-lib iq-ui -g form-screen src/app/registration --i18n-path src/assets/en.json
+  npx -p @unifylib/ui-lib iq-ui -g table-screen src/app/devices --labels-section DEVICE --api-uri /devices/list
+  npx -p @unifylib/ui-lib iq-ui -g dashboard src/app/home --import-path @unifylib/ui-lib
+
+  Local dev / linked build:
+  node node_modules/@unifylib/ui-lib/cli/index.js -g form-screen src/app/registration
+`);
+}
+
+/**
+ * @returns {{
+ *   type?: string,
+ *   destination?: string,
+ *   name?: string,
+ *   labelsSection?: string,
+ *   apiUri?: string,
+ *   fieldsCount: number,
+ *   importPath: string,
+ *   i18nPath?: string,
+ *   dryRun: boolean,
+ *   help: boolean,
+ * }}
+ */
+function parseArgs(argv) {
+  const out = {
+    fieldsCount: 6,
+    importPath: "@iq/ui-lib",
+    dryRun: false,
+    help: false,
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      out.help = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      out.dryRun = true;
+      continue;
+    }
+    if (a === "-g" || a === "--generate") {
+      out.type = argv[++i];
+      continue;
+    }
+    if (a === "--name") {
+      out.name = argv[++i];
+      continue;
+    }
+    if (a === "--labels-section") {
+      out.labelsSection = argv[++i];
+      continue;
+    }
+    if (a === "--api-uri") {
+      out.apiUri = argv[++i];
+      continue;
+    }
+    if (a === "--fields-count") {
+      out.fieldsCount = parseInt(argv[++i], 10) || 6;
+      continue;
+    }
+    if (a === "--import-path") {
+      out.importPath = argv[++i];
+      continue;
+    }
+    if (a === "--i18n-path") {
+      out.i18nPath = argv[++i];
+      continue;
+    }
+    if (a.startsWith("-")) {
+      console.error("Unknown option:", a);
+      process.exitCode = 1;
+      out.help = true;
+      return out;
+    }
+    if (!out.destination) {
+      out.destination = a;
+    } else {
+      console.error("Unexpected argument:", a);
+      process.exitCode = 1;
+      out.help = true;
+      return out;
+    }
+  }
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    process.exit(process.exitCode || 0);
+  }
+  if (!args.type || !args.destination) {
+    console.error("Missing required: -g <type> and <destination>\n");
+    printHelp();
+    process.exit(1);
+  }
+
+  const gen = GENERATORS[args.type];
+  if (!gen || typeof gen.generate !== "function") {
+    console.error("Unknown generator type:", args.type);
+    printHelp();
+    process.exit(1);
+  }
+
+  const rawName = args.name || lastPathSegment(args.destination);
+  const kebab = kebabCase(rawName);
+  const pascal = pascalCase(rawName);
+  const labelsSection = args.labelsSection || upperSnakeFromKebab(kebab);
+  const apiUri = args.apiUri != null ? args.apiUri : `/${kebab}`;
+
+  const destDir = path.isAbsolute(args.destination)
+    ? args.destination
+    : path.join(process.cwd(), args.destination);
+
+  const ctx = {
+    kebab,
+    pascal,
+    labelsSection,
+    apiUri,
+    importPath: args.importPath,
+    fieldsCount: args.fieldsCount,
+  };
+
+  const files = gen.generate(ctx);
+  writeFiles({ destDir, dryRun: args.dryRun }, files);
+
+  if (args.i18nPath && typeof gen.getTranslations === "function") {
+    const translations = gen.getTranslations(ctx);
+    if (translations && Object.keys(translations).length > 0) {
+      upsertI18nEntries(args.i18nPath, translations, args.dryRun);
+    }
+  }
+}
+
+main();

package/cli/utils.js

@@ -0,0 +1,228 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * @param {string} destPath
+ * @returns {string}
+ */
+function lastPathSegment(destPath) {
+  const normalized = destPath.replace(/\\/g, "/").replace(/\/+$/, "");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts[parts.length - 1] || "feature";
+}
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function kebabCase(str) {
+  return String(str)
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "") || "feature";
+}
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function pascalCase(str) {
+  return kebabCase(str)
+    .split("-")
+    .filter(Boolean)
+    .map((s) => s[0].toUpperCase() + s.slice(1))
+    .join("");
+}
+
+/**
+ * @param {string} kebab
+ * @returns {string}
+ */
+function upperSnakeFromKebab(kebab) {
+  return kebabCase(kebab)
+    .split("-")
+    .filter(Boolean)
+    .map((s) => s.toUpperCase())
+    .join("_");
+}
+
+/**
+ * @param {string} destDir
+ * @param {boolean} dryRun
+ */
+function ensureDir(destDir, dryRun) {
+  if (dryRun) return;
+  fs.mkdirSync(destDir, { recursive: true });
+}
+
+/**
+ * @param {string} filePath
+ * @param {string} content
+ * @param {boolean} dryRun
+ */
+function writeFile(filePath, content, dryRun) {
+  if (dryRun) {
+    console.log(`[dry-run] would write ${filePath} (${content.length} bytes)`);
+    return;
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  console.log(`Wrote ${filePath}`);
+}
+
+/**
+ * @param {{ destDir: string, dryRun: boolean }} opts
+ * @param {Array<{ relative: string, content: string }>} files
+ */
+function writeFiles(opts, files) {
+  ensureDir(opts.destDir, opts.dryRun);
+  for (const f of files) {
+    const filePath = path.join(opts.destDir, f.relative);
+    writeFile(filePath, f.content, opts.dryRun);
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} target
+ * @param {string[]} pathParts
+ * @param {string} value
+ */
+function setNested(target, pathParts, value) {
+  let cursor = target;
+  for (let i = 0; i < pathParts.length; i++) {
+    const part = pathParts[i];
+    const isLeaf = i === pathParts.length - 1;
+    if (isLeaf) {
+      cursor[part] = value;
+      return;
+    }
+    if (typeof cursor[part] !== "object" || cursor[part] === null || Array.isArray(cursor[part])) {
+      cursor[part] = {};
+    }
+    cursor = /** @type {Record<string, unknown>} */ (cursor[part]);
+  }
+}
+
+/**
+ * @param {string} targetPath
+ * @returns {string[]}
+ */
+function resolveJsonTargets(targetPath) {
+  const fullPath = path.isAbsolute(targetPath) ? targetPath : path.join(process.cwd(), targetPath);
+  if (!fs.existsSync(fullPath)) {
+    return [fullPath];
+  }
+
+  const stat = fs.statSync(fullPath);
+  if (stat.isFile()) {
+    return [fullPath];
+  }
+
+  if (!stat.isDirectory()) {
+    return [fullPath];
+  }
+
+  /** @type {string[]} */
+  const out = [];
+  /** @param {string} fileName */
+  function isTranslationFileName(fileName) {
+    const lower = fileName.toLowerCase();
+    // Common translation file patterns
+    // - en.json / ar.json
+    // - en-us.json / ar-QA.json
+    // - messages.en.json / messages-ar.json
+    return (
+      /^(en|ar)([-_][a-z0-9]+)*\.json$/i.test(lower) ||
+      /\.((en|ar)([-_][a-z0-9]+)*)\.json$/i.test(lower) ||
+      lower.includes("i18n")
+    );
+  }
+  /** @param {string} dir */
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(entryPath);
+      } else if (entry.isFile() && isTranslationFileName(entry.name)) {
+        out.push(entryPath);
+      }
+    }
+  }
+
+  walk(fullPath);
+  return out;
+}
+
+/**
+ * @param {string} i18nPath
+ * @param {Record<string, string>} entries
+ * @param {boolean} dryRun
+ */
+function upsertI18nEntries(i18nPath, entries, dryRun) {
+  const targets = resolveJsonTargets(i18nPath);
+  if (targets.length === 0) {
+    console.log(`No JSON files found in i18n target: ${i18nPath}`);
+    return;
+  }
+
+  for (const fullPath of targets) {
+  if (dryRun) {
+    console.log(`[dry-run] would update i18n file ${fullPath} with ${Object.keys(entries).length} keys`);
+    continue;
+  }
+
+  let data = {};
+  if (fs.existsSync(fullPath)) {
+    const raw = fs.readFileSync(fullPath, "utf8").trim();
+    data = raw ? JSON.parse(raw) : {};
+  } else {
+    const parent = path.dirname(fullPath);
+    fs.mkdirSync(parent, { recursive: true });
+  }
+
+  for (const [key, value] of Object.entries(entries)) {
+    const parts = key.split(".").filter(Boolean);
+    if (parts.length === 0) continue;
+    setNested(data, parts, value);
+  }
+
+  fs.writeFileSync(fullPath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+  console.log(`Updated i18n ${fullPath}`);
+  }
+}
+
+/**
+ * Generate placeholder FieldInfo rows (2 per row by default).
+ * @param {number} count
+ * @param {number} perRow
+ * @param {string} indent
+ * @returns {string}
+ */
+function buildFieldInfoLines(count, perRow, indent) {
+  const lines = [];
+  for (let i = 1; i <= count; i++) {
+    const row = Math.ceil(i / perRow);
+    lines.push(
+      `${indent}new FieldInfo({ row: ${row}, property: "field${i}", label: "field${i}", required: false, type: "text", validators: [Validators.maxLength(100)], validationMessages: { maxlength: "VALIDATION_MAX_100" } })`
+    );
+  }
+  return lines.join(",\n");
+}
+
+module.exports = {
+  lastPathSegment,
+  kebabCase,
+  pascalCase,
+  upperSnakeFromKebab,
+  ensureDir,
+  writeFile,
+  writeFiles,
+  buildFieldInfoLines,
+  resolveJsonTargets,
+  upsertI18nEntries,
+};

package/esm2022/lib/components/action-comment/action-comment.component.mjs

@@ -49,7 +49,7 @@ export class ActionCommentComponent {
         this.signingRequired = this.data.signingRequired;
         this.tokenReference = this.data.tokenReference;
         this.warningMsg = this.data.warningMsg || false;
-        this.itemName = this.data.deviceName;
+        this.itemName = this.data.itemName;
         this.titleKey = this.data.titleKey;
         this.subtitleKey = this.data.subtitleKey;
         this.reasonLabelKey = this.data.reasonLabelKey;
@@ -108,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: HostListener,
                 args: ['window:keyup.esc']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-comment.component.js","sourceRoot":"","sources":["../../../../../../../projects/invoiceq/ui-lib/src/lib/components/action-comment/action-comment.component.ts","../../../../../../../projects/invoiceq/ui-lib/src/lib/components/action-comment/action-comment.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostListener, Inject, OnInit } from '@angular/core';\r\nimport {\r\n  MAT_DIALOG_DATA,\r\n  MatDialogActions,\r\n  MatDialogContent,\r\n  MatDialogRef,\r\n  MatDialogTitle\r\n} from '@angular/material/dialog';\r\nimport { MatFormField, MatLabel } from '@angular/material/form-field';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { CdkTextareaAutosize } from '@angular/cdk/text-field';\r\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\r\nimport { MatButton } from '@angular/material/button';\r\nimport { MatInput } from '@angular/material/input';\r\nimport { MatIcon } from '@angular/material/icon';\r\nimport { MatOption } from '@angular/material/core';\r\nimport { MatSelect } from '@angular/material/select';\r\nimport { NgForOf, NgIf } from '@angular/common';\r\n\r\n@Component({\r\n  selector: 'app-action-comment',\r\n  standalone: true,\r\n  imports: [\r\n    MatDialogTitle,\r\n    MatFormField,\r\n    MatLabel,\r\n    MatDialogContent,\r\n    FormsModule,\r\n    CdkTextareaAutosize,\r\n    TranslateModule,\r\n    MatDialogActions,\r\n    MatButton,\r\n    MatInput,\r\n    MatIcon,\r\n    MatOption,\r\n    MatSelect,\r\n    NgForOf,\r\n    NgIf\r\n  ],\r\n  templateUrl: './action-comment.component.html',\r\n  styleUrl: './action-comment.component.css'\r\n})\r\nexport class ActionCommentComponent implements OnInit {\r\n  itemName: string = '';\r\n  titleKey: string = '';\r\n  subtitleKey: string = '';\r\n  reasonLabelKey: string = '';\r\n  placeholderKey: string = '';\r\n  warningKey: string = '';\r\n  cancelKey: string = '';\r\n  actionKey: string = '';\r\n  currentDirection: 'ltr' | 'rtl' = 'ltr';\r\n\r\n  actionLabel : string =''\r\n  isTermination : boolean=false;\r\n  comment: string = '';\r\n  otherComment: string = '';\r\n  external: boolean = false;\r\n  signingRequired: boolean = false;\r\n  tokenReference: string = \"\";\r\n  otp: string = \"\";\r\n  isSubmitted: boolean = false;\r\n  warningMsg = false;\r\n\r\n  constructor(public dialogRef: MatDialogRef<ActionCommentComponent>,\r\n              @Inject(MAT_DIALOG_DATA) public data: any,\r\n              public translate: TranslateService) {\r\n    dialogRef.disableClose = true;\r\n  }\r\n  @HostListener('window:keyup.esc') onKeyUp() {\r\n    this.dialogRef.close();\r\n  }\r\n  ngOnInit(): void {\r\n    this.actionLabel = this.data.label;\r\n    this.isTermination = this.data.isTermination ;\r\n    this.signingRequired = this.data.signingRequired;\r\n    this.tokenReference = this.data.tokenReference;\r\n    this.warningMsg = this.data.warningMsg || false;\r\n\r\n    this.itemName = this.data.deviceName;\r\n    this.titleKey = this.data.titleKey;\r\n    this.subtitleKey = this.data.subtitleKey;\r\n    this.reasonLabelKey = this.data.reasonLabelKey;\r\n    this.placeholderKey = this.data.placeholderKey;\r\n    this.warningKey = this.data.warningKey;\r\n    this.cancelKey = this.data.cancelKey;\r\n    this.actionKey = this.data.actionKey;\r\n    this.currentDirection  = this.data.direction;\r\n  }\r\n\r\n\r\n  commentAndClose() {\r\n    this.isSubmitted = true;\r\n\r\n    if (this.signingRequired && !this.otp) {\r\n      return false;\r\n    }\r\n\r\n    const finalComment =\r\n      this.comment === 'OTHER' ? this.otherComment : this.translate.instant(this.comment);\r\n\r\n    const obj: { [key: string]: any } = {\r\n      comment: finalComment,\r\n      shareExternal: this.external\r\n    };\r\n\r\n    if (this.signingRequired) {\r\n      obj['token'] = this.otp;\r\n      obj['tokenReference'] = this.tokenReference;\r\n    }\r\n\r\n    this.dialogRef.close(obj);\r\n    return true;\r\n  }\r\n\r\n  cancel() {\r\n    this.dialogRef.close();\r\n  }\r\n\r\n}\r\n","<div class=\"dialog-container\" [dir]=\"currentDirection\">\r\n\r\n  <div class=\"desktop-view\">\r\n    <h2 mat-dialog-title class=\"dialog-title\">\r\n      {{ titleKey | translate}} {{itemName}}\r\n    </h2>\r\n\r\n    <p class=\"dialog-subtitle\">\r\n      {{ subtitleKey | translate }}\r\n    </p>\r\n\r\n    <mat-dialog-content class=\"content-section\">\r\n\r\n      <ng-container *ngIf=\"data?.options?.length; else textMode\">\r\n\r\n        <mat-form-field appearance=\"outline\" class=\"w-100\">\r\n          <mat-label>{{ reasonLabelKey | translate }}</mat-label>\r\n          <mat-select\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\">\r\n\r\n            <mat-option *ngFor=\"let item of data.options\" [value]=\"item\">\r\n              {{ data.translate ? (item | translate) : item }}\r\n            </mat-option>\r\n\r\n          </mat-select>\r\n        </mat-form-field>\r\n\r\n        <mat-form-field\r\n          *ngIf=\"comment === 'OTHER'\"\r\n          appearance=\"outline\"\r\n          class=\"w-100\">\r\n          <mat-label>{{ placeholderKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"otherComment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            maxlength=\"1000\"\r\n            cdkAutosizeMaxRows=\"5\">\r\n          </textarea>\r\n        </mat-form-field>\r\n\r\n      </ng-container>\r\n\r\n      <ng-template #textMode>\r\n        <mat-form-field appearance=\"outline\" class=\"w-100\">\r\n          <mat-label>{{ reasonLabelKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            maxlength=\"1000\"\r\n            cdkAutosizeMaxRows=\"5\">\r\n          </textarea>\r\n        </mat-form-field>\r\n      </ng-template>\r\n\r\n      <div class=\"info-box\">\r\n        <mat-icon>info</mat-icon>\r\n        <span class=\"info-text\">\r\n          {{ warningKey | translate }}\r\n        </span>\r\n      </div>\r\n\r\n    </mat-dialog-content>\r\n\r\n    <mat-dialog-actions align=\"end\" class=\"footer-actions\">\r\n      <button mat-stroked-button class=\"btn-none-background-primary cancel-btn\" (click)=\"cancel()\">\r\n        {{ cancelKey | translate }}\r\n      </button>\r\n\r\n      <button\r\n        mat-flat-button\r\n        class=\"btn-background-primary warn-btn\"\r\n        (click)=\"commentAndClose()\"\r\n        [disabled]=\"!comment || (comment === 'OTHER' && !otherComment)\">\r\n        {{ actionKey | translate }}\r\n      </button>\r\n    </mat-dialog-actions>\r\n  </div>\r\n\r\n  <div class=\"mobile-view\">\r\n    <div class=\"modal-header\">\r\n      <div class=\"handle\"></div>\r\n      <div class=\"header-content\">\r\n        <p class=\"modal-title\">{{ titleKey | translate }}</p>\r\n        <button class=\"close-button\" (click)=\"cancel()\">\r\n          <mat-icon>close</mat-icon>\r\n        </button>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"modal-body\">\r\n\r\n      <ng-container *ngIf=\"data?.options?.length; else mobileText\">\r\n\r\n        <mat-form-field appearance=\"outline\" class=\"textarea-field-mobile\">\r\n          <mat-label>{{ reasonLabelKey | translate }} {{ itemName }}</mat-label>\r\n          <mat-select\r\n            [(ngModel)]=\"comment\"\r\n            class=\"textarea-mobile\">\r\n\r\n            <mat-option *ngFor=\"let item of data.options\" [value]=\"item\">\r\n              {{ data.translate ? ( item | translate) : item }}\r\n            </mat-option>\r\n\r\n          </mat-select>\r\n        </mat-form-field>\r\n\r\n        <mat-form-field\r\n          *ngIf=\"comment === 'OTHER'\"\r\n          appearance=\"outline\"\r\n          class=\"textarea-field-mobile\">\r\n          <mat-label>{{ placeholderKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"otherComment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            cdkAutosizeMaxRows=\"5\"\r\n            maxlength=\"1000\"\r\n            class=\"textarea-mobile\">\r\n          </textarea>\r\n        </mat-form-field>\r\n\r\n      </ng-container>\r\n\r\n      <ng-template #mobileText>\r\n        <mat-form-field appearance=\"outline\" class=\"textarea-field-mobile\">\r\n          <mat-label>{{ reasonLabelKey | translate }} {{ itemName }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            cdkAutosizeMaxRows=\"5\"\r\n            maxlength=\"1000\"\r\n            class=\"textarea-mobile\">\r\n          </textarea>\r\n        </mat-form-field>\r\n      </ng-template>\r\n\r\n      <div class=\"info-box-mobile\">\r\n        <mat-icon class=\"info-icon-mobile\">info</mat-icon>\r\n        <span class=\"info-text-mobile\">\r\n          {{ warningKey | translate }}\r\n        </span>\r\n      </div>\r\n\r\n    </div>\r\n\r\n    <div class=\"modal-actions-mobile\">\r\n      <div class=\"actions-buttons-container\">\r\n        <button mat-stroked-button class=\"btn-cancel-mobile\" (click)=\"cancel()\">\r\n          {{ cancelKey | translate }}\r\n        </button>\r\n        <button\r\n          mat-flat-button\r\n          class=\"btn-action-mobile\"\r\n          (click)=\"commentAndClose()\"\r\n          [disabled]=\"!comment || (comment === 'OTHER' && !otherComment)\">\r\n          {{ actionKey | translate }}\r\n        </button>\r\n      </div>\r\n      <div class=\"home-indicator\"></div>\r\n    </div>\r\n  </div>\r\n\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-comment.component.js","sourceRoot":"","sources":["../../../../../../../projects/invoiceq/ui-lib/src/lib/components/action-comment/action-comment.component.ts","../../../../../../../projects/invoiceq/ui-lib/src/lib/components/action-comment/action-comment.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostListener, Inject, OnInit } from '@angular/core';\r\nimport {\r\n  MAT_DIALOG_DATA,\r\n  MatDialogActions,\r\n  MatDialogContent,\r\n  MatDialogRef,\r\n  MatDialogTitle\r\n} from '@angular/material/dialog';\r\nimport { MatFormField, MatLabel } from '@angular/material/form-field';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { CdkTextareaAutosize } from '@angular/cdk/text-field';\r\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\r\nimport { MatButton } from '@angular/material/button';\r\nimport { MatInput } from '@angular/material/input';\r\nimport { MatIcon } from '@angular/material/icon';\r\nimport { MatOption } from '@angular/material/core';\r\nimport { MatSelect } from '@angular/material/select';\r\nimport { NgForOf, NgIf } from '@angular/common';\r\n\r\n@Component({\r\n  selector: 'app-action-comment',\r\n  standalone: true,\r\n  imports: [\r\n    MatDialogTitle,\r\n    MatFormField,\r\n    MatLabel,\r\n    MatDialogContent,\r\n    FormsModule,\r\n    CdkTextareaAutosize,\r\n    TranslateModule,\r\n    MatDialogActions,\r\n    MatButton,\r\n    MatInput,\r\n    MatIcon,\r\n    MatOption,\r\n    MatSelect,\r\n    NgForOf,\r\n    NgIf\r\n  ],\r\n  templateUrl: './action-comment.component.html',\r\n  styleUrl: './action-comment.component.css'\r\n})\r\nexport class ActionCommentComponent implements OnInit {\r\n  itemName: string = '';\r\n  titleKey: string = '';\r\n  subtitleKey: string = '';\r\n  reasonLabelKey: string = '';\r\n  placeholderKey: string = '';\r\n  warningKey: string = '';\r\n  cancelKey: string = '';\r\n  actionKey: string = '';\r\n  currentDirection: 'ltr' | 'rtl' = 'ltr';\r\n\r\n  actionLabel : string =''\r\n  isTermination : boolean=false;\r\n  comment: string = '';\r\n  otherComment: string = '';\r\n  external: boolean = false;\r\n  signingRequired: boolean = false;\r\n  tokenReference: string = \"\";\r\n  otp: string = \"\";\r\n  isSubmitted: boolean = false;\r\n  warningMsg = false;\r\n\r\n  constructor(public dialogRef: MatDialogRef<ActionCommentComponent>,\r\n              @Inject(MAT_DIALOG_DATA) public data: any,\r\n              public translate: TranslateService) {\r\n    dialogRef.disableClose = true;\r\n  }\r\n  @HostListener('window:keyup.esc') onKeyUp() {\r\n    this.dialogRef.close();\r\n  }\r\n  ngOnInit(): void {\r\n    this.actionLabel = this.data.label;\r\n    this.isTermination = this.data.isTermination ;\r\n    this.signingRequired = this.data.signingRequired;\r\n    this.tokenReference = this.data.tokenReference;\r\n    this.warningMsg = this.data.warningMsg || false;\r\n\r\n    this.itemName = this.data.itemName;\r\n    this.titleKey = this.data.titleKey;\r\n    this.subtitleKey = this.data.subtitleKey;\r\n    this.reasonLabelKey = this.data.reasonLabelKey;\r\n    this.placeholderKey = this.data.placeholderKey;\r\n    this.warningKey = this.data.warningKey;\r\n    this.cancelKey = this.data.cancelKey;\r\n    this.actionKey = this.data.actionKey;\r\n    this.currentDirection  = this.data.direction;\r\n  }\r\n\r\n\r\n  commentAndClose() {\r\n    this.isSubmitted = true;\r\n\r\n    if (this.signingRequired && !this.otp) {\r\n      return false;\r\n    }\r\n\r\n    const finalComment =\r\n      this.comment === 'OTHER' ? this.otherComment : this.translate.instant(this.comment);\r\n\r\n    const obj: { [key: string]: any } = {\r\n      comment: finalComment,\r\n      shareExternal: this.external\r\n    };\r\n\r\n    if (this.signingRequired) {\r\n      obj['token'] = this.otp;\r\n      obj['tokenReference'] = this.tokenReference;\r\n    }\r\n\r\n    this.dialogRef.close(obj);\r\n    return true;\r\n  }\r\n\r\n  cancel() {\r\n    this.dialogRef.close();\r\n  }\r\n\r\n}\r\n","<div class=\"dialog-container\" [dir]=\"currentDirection\">\r\n\r\n  <div class=\"desktop-view\">\r\n    <h2 mat-dialog-title class=\"dialog-title\">\r\n      {{ titleKey | translate}} {{itemName}}\r\n    </h2>\r\n\r\n    <p class=\"dialog-subtitle\">\r\n      {{ subtitleKey | translate }}\r\n    </p>\r\n\r\n    <mat-dialog-content class=\"content-section\">\r\n\r\n      <ng-container *ngIf=\"data?.options?.length; else textMode\">\r\n\r\n        <mat-form-field appearance=\"outline\" class=\"w-100\">\r\n          <mat-label>{{ reasonLabelKey | translate }}</mat-label>\r\n          <mat-select\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\">\r\n\r\n            <mat-option *ngFor=\"let item of data.options\" [value]=\"item\">\r\n              {{ data.translate ? (item | translate) : item }}\r\n            </mat-option>\r\n\r\n          </mat-select>\r\n        </mat-form-field>\r\n\r\n        <mat-form-field\r\n          *ngIf=\"comment === 'OTHER'\"\r\n          appearance=\"outline\"\r\n          class=\"w-100\">\r\n          <mat-label>{{ placeholderKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"otherComment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            maxlength=\"1000\"\r\n            cdkAutosizeMaxRows=\"5\">\r\n          </textarea>\r\n        </mat-form-field>\r\n\r\n      </ng-container>\r\n\r\n      <ng-template #textMode>\r\n        <mat-form-field appearance=\"outline\" class=\"w-100\">\r\n          <mat-label>{{ reasonLabelKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            maxlength=\"1000\"\r\n            cdkAutosizeMaxRows=\"5\">\r\n          </textarea>\r\n        </mat-form-field>\r\n      </ng-template>\r\n\r\n      <div class=\"info-box\">\r\n        <mat-icon>info</mat-icon>\r\n        <span class=\"info-text\">\r\n          {{ warningKey | translate }}\r\n        </span>\r\n      </div>\r\n\r\n    </mat-dialog-content>\r\n\r\n    <mat-dialog-actions align=\"end\" class=\"footer-actions\">\r\n      <button mat-stroked-button class=\"btn-none-background-primary cancel-btn\" (click)=\"cancel()\">\r\n        {{ cancelKey | translate }}\r\n      </button>\r\n\r\n      <button\r\n        mat-flat-button\r\n        class=\"btn-background-primary warn-btn\"\r\n        (click)=\"commentAndClose()\"\r\n        [disabled]=\"!comment || (comment === 'OTHER' && !otherComment)\">\r\n        {{ actionKey | translate }}\r\n      </button>\r\n    </mat-dialog-actions>\r\n  </div>\r\n\r\n  <div class=\"mobile-view\">\r\n    <div class=\"modal-header\">\r\n      <div class=\"handle\"></div>\r\n      <div class=\"header-content\">\r\n        <p class=\"modal-title\">{{ titleKey | translate }}</p>\r\n        <button class=\"close-button\" (click)=\"cancel()\">\r\n          <mat-icon>close</mat-icon>\r\n        </button>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"modal-body\">\r\n\r\n      <ng-container *ngIf=\"data?.options?.length; else mobileText\">\r\n\r\n        <mat-form-field appearance=\"outline\" class=\"textarea-field-mobile\">\r\n          <mat-label>{{ reasonLabelKey | translate }} {{ itemName }}</mat-label>\r\n          <mat-select\r\n            [(ngModel)]=\"comment\"\r\n            class=\"textarea-mobile\">\r\n\r\n            <mat-option *ngFor=\"let item of data.options\" [value]=\"item\">\r\n              {{ data.translate ? ( item | translate) : item }}\r\n            </mat-option>\r\n\r\n          </mat-select>\r\n        </mat-form-field>\r\n\r\n        <mat-form-field\r\n          *ngIf=\"comment === 'OTHER'\"\r\n          appearance=\"outline\"\r\n          class=\"textarea-field-mobile\">\r\n          <mat-label>{{ placeholderKey | translate }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"otherComment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            cdkAutosizeMaxRows=\"5\"\r\n            maxlength=\"1000\"\r\n            class=\"textarea-mobile\">\r\n          </textarea>\r\n        </mat-form-field>\r\n\r\n      </ng-container>\r\n\r\n      <ng-template #mobileText>\r\n        <mat-form-field appearance=\"outline\" class=\"textarea-field-mobile\">\r\n          <mat-label>{{ reasonLabelKey | translate }} {{ itemName }}</mat-label>\r\n          <textarea\r\n            matInput\r\n            [(ngModel)]=\"comment\"\r\n            [placeholder]=\"placeholderKey | translate\"\r\n            cdkTextareaAutosize\r\n            cdkAutosizeMinRows=\"4\"\r\n            cdkAutosizeMaxRows=\"5\"\r\n            maxlength=\"1000\"\r\n            class=\"textarea-mobile\">\r\n          </textarea>\r\n        </mat-form-field>\r\n      </ng-template>\r\n\r\n      <div class=\"info-box-mobile\">\r\n        <mat-icon class=\"info-icon-mobile\">info</mat-icon>\r\n        <span class=\"info-text-mobile\">\r\n          {{ warningKey | translate }}\r\n        </span>\r\n      </div>\r\n\r\n    </div>\r\n\r\n    <div class=\"modal-actions-mobile\">\r\n      <div class=\"actions-buttons-container\">\r\n        <button mat-stroked-button class=\"btn-cancel-mobile\" (click)=\"cancel()\">\r\n          {{ cancelKey | translate }}\r\n        </button>\r\n        <button\r\n          mat-flat-button\r\n          class=\"btn-action-mobile\"\r\n          (click)=\"commentAndClose()\"\r\n          [disabled]=\"!comment || (comment === 'OTHER' && !otherComment)\">\r\n          {{ actionKey | translate }}\r\n        </button>\r\n      </div>\r\n      <div class=\"home-indicator\"></div>\r\n    </div>\r\n  </div>\r\n\r\n</div>\r\n"]}