@simple-reporting/base 1.0.33 → 1.0.35

package/srl/.srl/composables/menu.ts

@@ -91,9 +91,12 @@ export default function useMenu(
     try {
       const route = useRoute();
       menus[name] = computed<NsWowNavigationItem[]>(() => {
-        return config.value.menus[config.value.locale][name].map((item) => {
-          return buildNav(item, route);
-        });
+        if (config.value.menus[config.value.locale][name]) {
+          return config.value.menus[config.value.locale][name].map((item) => {
+            return buildNav(item, route);
+          });
+        }
+        return [];
       });
 
       return menus[name];

package/srl/.srl/composables/srlConfig.ts

@@ -0,0 +1,3 @@
+export default function useSrlConfig(): unknown {
+  return {}
+}

package/srl/.srl/types/global.d.ts

@@ -1,6 +1,17 @@
 import { App } from 'vue'
 export {}
 declare global {
+  type SrlDevToolsSettings = {
+    active: boolean
+    size: string
+    position: string
+    opacity: number
+    darkMode: boolean
+    overlay: {
+      grid: boolean
+    }
+  }
+  type SrlDevToolsDialog = null | "grid" | "spacer" | "typo" | "colors" | "settings" | "viewport"
   interface Window {
     app: App;
   }

package/srl/.srl/types/nswow.d.ts

@@ -1,3 +1,5 @@
+import type { VNode } from 'vue';
+
 export {};
 declare global {
   type NsWowSettings = {
@@ -98,6 +100,9 @@ declare global {
     icon?: string;
     iconBefore?: string;
     iconAfter?: string;
+    svg?: VNode | string;
+    svgBefore?: VNode | string;
+    svgAfter?: VNode | string;
     img?: {
       src: string;
       alt?: string;

package/srl/.srl/utils/html.ts

@@ -77,8 +77,8 @@ export function prepareHtmlContent(text: string): string {
     });
 
     text = text.replace(
-        /<template-([a-z]+)>([\s\S]*?)<\/template-\1>/g,
-        (_match, name, content) => `<template #${name}>${content}</template>`
+      /<template-([a-z]+)([^>]*)>([\s\S]*?)<\/template-\1>/g,
+      (_match, name, attrs, content) => `<template ${attrs} #${name}>${content}</template>`
     );
 
     text = text.replace(/<style[^>]*>([\s\S]*?)<\/style>/gi, (match, p1) => {

package/srl/.srl/utils/index.ts

@@ -1,33 +1,35 @@
 import { isFilePath, isRouterPath, isExternalPath } from './uri';
 import { camelCase } from './string';
 import { prepareHtmlContent } from './html';
+import { objectDeepAssign } from './object'
 import {
-    usePageState,
-    clearPageState,
-    isDialogStored,
-    addDialogToStorage,
-    getDialogFromStorage,
-    getDialogStorage,
-    isAccordionAnchored,
-    setAccordionAnchored,
-    isMounted,
-    setMounted
+  usePageState,
+  clearPageState,
+  isDialogStored,
+  addDialogToStorage,
+  getDialogFromStorage,
+  getDialogStorage,
+  isAccordionAnchored,
+  setAccordionAnchored,
+  isMounted,
+  setMounted
 } from './pageState.ts';
 
 export {
-    isFilePath,
-    isRouterPath,
-    isExternalPath,
-    camelCase,
-    prepareHtmlContent,
-    usePageState,
-    clearPageState,
-    isAccordionAnchored,
-    setAccordionAnchored,
-    isDialogStored,
-    addDialogToStorage,
-    getDialogFromStorage,
-    getDialogStorage,
-    setMounted,
-    isMounted,
+  isFilePath,
+  isRouterPath,
+  isExternalPath,
+  camelCase,
+  prepareHtmlContent,
+  usePageState,
+  clearPageState,
+  isAccordionAnchored,
+  setAccordionAnchored,
+  isDialogStored,
+  addDialogToStorage,
+  getDialogFromStorage,
+  getDialogStorage,
+  setMounted,
+  isMounted,
+  objectDeepAssign
 };

package/srl/.srl/utils/object.ts

@@ -0,0 +1,60 @@
+type PlainObject = Record<string, any>;
+
+export function objectDeepAssign<T extends PlainObject>(target: T, source: Partial<T>): T {
+  // Defensive guard: API erwartet Root-Objekte, keine Arrays.
+  if (Array.isArray(target) || Array.isArray(source)) {
+    throw new TypeError('objectDeepAssign erwartet Objekte als Root-Parameter');
+  }
+
+  for (const key in source) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+
+    const sourceValue = (source as PlainObject)[key];
+    const targetValue = (target as PlainObject)[key];
+
+    (target as PlainObject)[key] = mergeNode(targetValue, sourceValue);
+  }
+
+  return target;
+}
+
+function mergeNode(targetValue: any, sourceValue: any): any {
+  // Arrays nur intern behandeln (verschachtelte Knoten)
+  if (Array.isArray(sourceValue)) {
+    const targetArr = Array.isArray(targetValue) ? targetValue : [];
+    return mergeArray(targetArr, sourceValue);
+  }
+
+  // Plain Objects rekursiv mergen
+  if (isPlainObject(sourceValue)) {
+    const base = isPlainObject(targetValue) ? targetValue : {};
+    return objectDeepAssign(base, sourceValue);
+  }
+
+  // Primitive / null / Funktionen etc. überschreiben
+  return sourceValue;
+}
+
+function mergeArray(targetArr: any[], sourceArr: any[]): any[] {
+  // Vereint beide Längen: neue source-Elemente kommen dazu,
+  // bestehende target-Reste bleiben erhalten.
+  const maxLen = Math.max(targetArr.length, sourceArr.length);
+  const result = new Array(maxLen);
+
+  for (let i = 0; i < maxLen; i++) {
+    const hasSource = i < sourceArr.length;
+
+    if (!hasSource) {
+      result[i] = targetArr[i];
+      continue;
+    }
+
+    result[i] = mergeNode(targetArr[i], sourceArr[i]);
+  }
+
+  return result;
+}
+
+function isPlainObject(value: unknown): value is PlainObject {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}