@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/password/password-check.js

@@ -1,52 +1,82 @@
-import { propertyName } from '../utils/object/property-name.js';
-import { timeout } from '../utils/timing.js';
-import { isNotNullOrUndefined, isUndefined } from '../utils/type-guards.js';
-import { haveIBeenPwned } from './have-i-been-pwned.js';
-import { passwordCheckLocalizationKeys } from './password-check.localization.js';
-export async function checkPassword(password, { checkForPwned = true } = {}) {
-    const zxcvbn = await getZxcvbn();
-    const [zxcvbnResult, pwnedResult] = await Promise.all([
-        zxcvbn(password),
-        checkForPwned ? Promise.race([haveIBeenPwned(password).catch(() => undefined), timeout(1000).then(() => undefined)]) : undefined
-    ]);
-    const pwnedWarnings = (isNotNullOrUndefined(pwnedResult) && (pwnedResult > 0)) ? [passwordCheckLocalizationKeys.tstdl.passwordCheck.warnings.pwned[propertyName]] : [];
-    const warnings = isNotNullOrUndefined(zxcvbnResult.feedback.warning)
-        ? [...pwnedWarnings, passwordCheckLocalizationKeys.tstdl.passwordCheck.warnings[zxcvbnResult.feedback.warning][propertyName]]
-        : pwnedWarnings;
-    const suggestions = zxcvbnResult.feedback.suggestions
-        .map((suggestion) => passwordCheckLocalizationKeys.tstdl.passwordCheck.suggestions[suggestion][propertyName]);
-    return {
-        strength: ((pwnedResult ?? 0) > 0) ? 0 : zxcvbnResult.score,
-        pwned: pwnedResult,
-        warnings,
-        suggestions
-    };
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var password_check_exports = {};
+__export(password_check_exports, {
+  checkPassword: () => checkPassword
+});
+module.exports = __toCommonJS(password_check_exports);
+var import_property_name = require("../utils/object/property-name.js");
+var import_timing = require("../utils/timing.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_have_i_been_pwned = require("./have-i-been-pwned.js");
+var import_password_check_localization = require("./password-check.localization.js");
+async function checkPassword(password, { checkForPwned = true } = {}) {
+  const zxcvbn = await getZxcvbn();
+  const [zxcvbnResult, pwnedResult] = await Promise.all([
+    zxcvbn(password),
+    checkForPwned ? Promise.race([(0, import_have_i_been_pwned.haveIBeenPwned)(password).catch(() => void 0), (0, import_timing.timeout)(1e3).then(() => void 0)]) : void 0
+  ]);
+  const pwnedWarnings = (0, import_type_guards.isNotNullOrUndefined)(pwnedResult) && pwnedResult > 0 ? [import_password_check_localization.passwordCheckLocalizationKeys.tstdl.passwordCheck.warnings.pwned[import_property_name.propertyName]] : [];
+  const warnings = (0, import_type_guards.isNotNullOrUndefined)(zxcvbnResult.feedback.warning) ? [...pwnedWarnings, import_password_check_localization.passwordCheckLocalizationKeys.tstdl.passwordCheck.warnings[zxcvbnResult.feedback.warning][import_property_name.propertyName]] : pwnedWarnings;
+  const suggestions = zxcvbnResult.feedback.suggestions.map((suggestion) => import_password_check_localization.passwordCheckLocalizationKeys.tstdl.passwordCheck.suggestions[suggestion][import_property_name.propertyName]);
+  return {
+    strength: (pwnedResult ?? 0) > 0 ? 0 : zxcvbnResult.score,
+    pwned: pwnedResult,
+    warnings,
+    suggestions
+  };
 }
 let zxcvbnAsyncInstance;
 async function getZxcvbn() {
-    if (isUndefined(zxcvbnAsyncInstance)) {
-        zxcvbnAsyncInstance = importZxcvbn();
-    }
-    return zxcvbnAsyncInstance;
+  if ((0, import_type_guards.isUndefined)(zxcvbnAsyncInstance)) {
+    zxcvbnAsyncInstance = importZxcvbn();
+  }
+  return zxcvbnAsyncInstance;
 }
 async function importZxcvbn() {
-    const [{ zxcvbnAsync, zxcvbnOptions }, common, english, german] = await Promise.all([
-        import('@zxcvbn-ts/core'),
-        /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-        import('@zxcvbn-ts/language-common'),
-        import('@zxcvbn-ts/language-en'),
-        import('@zxcvbn-ts/language-de')
-        /* eslint-enable @typescript-eslint/no-unnecessary-condition */
-    ]);
-    const options = {
-        graphs: common.adjacencyGraphs,
-        useLevenshteinDistance: true,
-        dictionary: {
-            ...common.dictionary,
-            ...english.dictionary,
-            ...german.dictionary
-        }
-    };
-    zxcvbnOptions.setOptions(options);
-    return zxcvbnAsync;
+  const [{ zxcvbnAsync, zxcvbnOptions }, common, english, german] = await Promise.all([
+    import("@zxcvbn-ts/core"),
+    /* eslint-disable @typescript-eslint/no-unnecessary-condition */
+    import("@zxcvbn-ts/language-common"),
+    import("@zxcvbn-ts/language-en"),
+    import("@zxcvbn-ts/language-de")
+    /* eslint-enable @typescript-eslint/no-unnecessary-condition */
+  ]);
+  const options = {
+    graphs: common.adjacencyGraphs,
+    useLevenshteinDistance: true,
+    dictionary: {
+      ...common.dictionary,
+      ...english.dictionary,
+      ...german.dictionary
+    }
+  };
+  zxcvbnOptions.setOptions(options);
+  return zxcvbnAsync;
 }

package/password/password-check.localization.js

@@ -1,90 +1,115 @@
-import { getLocalizationKeys } from '../text/localization.service.js';
-export const passwordCheckLocalizationKeys = getLocalizationKeys();
-export const germanPasswordCheckLocalization = {
-    language: { code: 'de', name: 'Deutsch' },
-    keys: {
-        tstdl: {
-            passwordCheck: {
-                warnings: {
-                    straightRow: 'Gerade Linien von Tasten auf der Tastatur sind leicht zu erraten.',
-                    keyPattern: 'Kurze Tastaturmuster sind leicht zu erraten.',
-                    simpleRepeat: 'Sich wiederholende Zeichen wie "aaa" sind leicht zu erraten.',
-                    extendedRepeat: 'Sich wiederholende Zeichenmuster wie "abcabcabc" sind leicht zu erraten.',
-                    sequences: 'Häufige Zeichenfolgen wie "abc" sind leicht zu erraten.',
-                    recentYears: 'Die jüngsten Jahreszahlen sind leicht zu erraten.',
-                    dates: 'Ein Datum ist leicht zu erraten.',
-                    topTen: 'Dies ist ein sehr häufig verwendetes Passwort.',
-                    topHundred: 'Dies ist ein häufig verwendetes Passwort.',
-                    common: 'Dies ist ein oft verwendetes Passwort.',
-                    similarToCommon: 'Dies weist Ähnlichkeit zu anderen oft verwendeten Passwörtern auf.',
-                    wordByItself: 'Einzelne Wörter sind leicht zu erraten.',
-                    namesByThemselves: 'Einzelne Namen oder Nachnamen sind leicht zu erraten.',
-                    commonNames: 'Vornamen und Nachnamen sind leicht zu erraten.',
-                    userInputs: 'Es sollten keine persönlichen oder Seiten relevanten Daten vorkommen.',
-                    pwned: 'Ihr Kennwort wurde durch eine Datenpanne im Internet offengelegt (https://haveibeenpwned.com/passwords).'
-                },
-                suggestions: {
-                    l33t: 'Vorhersehbare Buchstabenersetzungen wie \'@\' für \'a\' vermeiden.',
-                    reverseWords: 'Umgekehrte Schreibweise von gebräuchlichen Wörtern vermeiden.',
-                    allUppercase: 'Einige, aber nicht alle Buchstaben groß schreiben.',
-                    capitalization: 'Nicht nur den ersten Buchstaben groß schreiben.',
-                    dates: 'Daten, die mit persönlichen Daten in Verbindung gebracht werden können, vermeiden.',
-                    recentYears: 'Die jüngsten Jahreszahlen vermeiden.',
-                    associatedYears: 'Jahre, die mit persönlichen Daten in Verbindung gebracht werden können, vermeiden.',
-                    sequences: 'Häufige Zeichenfolgen vermeiden.',
-                    repeated: 'Wort- und Zeichenwiederholungen vermeiden.',
-                    longerKeyboardPattern: 'Längere Tastaturmuster in unterschiedlicher Tipprichtung verwenden.',
-                    anotherWord: 'Weitere Wörter, die weniger häufig vorkommen, hinzufügen.',
-                    useWords: 'Mehrere Wörter verwenden, aber allgemeine Phrasen vermeiden.',
-                    noNeed: 'Es ist möglich, starke Passwörter zu erstellen, ohne Symbole, Zahlen oder Großbuchstaben zu verwenden.',
-                    pwned: 'Wenn Sie dieses Kennwort an anderer Stelle verwenden, sollten Sie es ändern.'
-                }
-            }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var password_check_localization_exports = {};
+__export(password_check_localization_exports, {
+  englishPasswordCheckLocalization: () => englishPasswordCheckLocalization,
+  germanPasswordCheckLocalization: () => germanPasswordCheckLocalization,
+  passwordCheckLocalizationKeys: () => passwordCheckLocalizationKeys
+});
+module.exports = __toCommonJS(password_check_localization_exports);
+var import_localization_service = require("../text/localization.service.js");
+const passwordCheckLocalizationKeys = (0, import_localization_service.getLocalizationKeys)();
+const germanPasswordCheckLocalization = {
+  language: { code: "de", name: "Deutsch" },
+  keys: {
+    tstdl: {
+      passwordCheck: {
+        warnings: {
+          straightRow: "Gerade Linien von Tasten auf der Tastatur sind leicht zu erraten.",
+          keyPattern: "Kurze Tastaturmuster sind leicht zu erraten.",
+          simpleRepeat: 'Sich wiederholende Zeichen wie "aaa" sind leicht zu erraten.',
+          extendedRepeat: 'Sich wiederholende Zeichenmuster wie "abcabcabc" sind leicht zu erraten.',
+          sequences: 'H\xE4ufige Zeichenfolgen wie "abc" sind leicht zu erraten.',
+          recentYears: "Die j\xFCngsten Jahreszahlen sind leicht zu erraten.",
+          dates: "Ein Datum ist leicht zu erraten.",
+          topTen: "Dies ist ein sehr h\xE4ufig verwendetes Passwort.",
+          topHundred: "Dies ist ein h\xE4ufig verwendetes Passwort.",
+          common: "Dies ist ein oft verwendetes Passwort.",
+          similarToCommon: "Dies weist \xC4hnlichkeit zu anderen oft verwendeten Passw\xF6rtern auf.",
+          wordByItself: "Einzelne W\xF6rter sind leicht zu erraten.",
+          namesByThemselves: "Einzelne Namen oder Nachnamen sind leicht zu erraten.",
+          commonNames: "Vornamen und Nachnamen sind leicht zu erraten.",
+          userInputs: "Es sollten keine pers\xF6nlichen oder Seiten relevanten Daten vorkommen.",
+          pwned: "Ihr Kennwort wurde durch eine Datenpanne im Internet offengelegt (https://haveibeenpwned.com/passwords)."
+        },
+        suggestions: {
+          l33t: "Vorhersehbare Buchstabenersetzungen wie '@' f\xFCr 'a' vermeiden.",
+          reverseWords: "Umgekehrte Schreibweise von gebr\xE4uchlichen W\xF6rtern vermeiden.",
+          allUppercase: "Einige, aber nicht alle Buchstaben gro\xDF schreiben.",
+          capitalization: "Nicht nur den ersten Buchstaben gro\xDF schreiben.",
+          dates: "Daten, die mit pers\xF6nlichen Daten in Verbindung gebracht werden k\xF6nnen, vermeiden.",
+          recentYears: "Die j\xFCngsten Jahreszahlen vermeiden.",
+          associatedYears: "Jahre, die mit pers\xF6nlichen Daten in Verbindung gebracht werden k\xF6nnen, vermeiden.",
+          sequences: "H\xE4ufige Zeichenfolgen vermeiden.",
+          repeated: "Wort- und Zeichenwiederholungen vermeiden.",
+          longerKeyboardPattern: "L\xE4ngere Tastaturmuster in unterschiedlicher Tipprichtung verwenden.",
+          anotherWord: "Weitere W\xF6rter, die weniger h\xE4ufig vorkommen, hinzuf\xFCgen.",
+          useWords: "Mehrere W\xF6rter verwenden, aber allgemeine Phrasen vermeiden.",
+          noNeed: "Es ist m\xF6glich, starke Passw\xF6rter zu erstellen, ohne Symbole, Zahlen oder Gro\xDFbuchstaben zu verwenden.",
+          pwned: "Wenn Sie dieses Kennwort an anderer Stelle verwenden, sollten Sie es \xE4ndern."
         }
-    },
-    enums: []
+      }
+    }
+  },
+  enums: []
 };
-export const englishPasswordCheckLocalization = {
-    language: { code: 'en', name: 'English' },
-    keys: {
-        tstdl: {
-            passwordCheck: {
-                warnings: {
-                    straightRow: 'Straight rows of keys on your keyboard are easy to guess.',
-                    keyPattern: 'Short keyboard patterns are easy to guess.',
-                    simpleRepeat: 'Repeated characters like "aaa" are easy to guess.',
-                    extendedRepeat: 'Repeated character patterns like "abcabcabc" are easy to guess.',
-                    sequences: 'Common character sequences like "abc" are easy to guess.',
-                    recentYears: 'Recent years are easy to guess.',
-                    dates: 'Dates are easy to guess.',
-                    topTen: 'This is a heavily used password.',
-                    topHundred: 'This is a frequently used password.',
-                    common: 'This is a commonly used password.',
-                    similarToCommon: 'This is similar to a commonly used password.',
-                    wordByItself: 'Single words are easy to guess.',
-                    namesByThemselves: 'Single names or surnames are easy to guess.',
-                    commonNames: 'Common names and surnames are easy to guess.',
-                    userInputs: 'There should not be any personal or page related data.',
-                    pwned: 'Your password was exposed by a data breach on the Internet (https://haveibeenpwned.com/passwords).'
-                },
-                suggestions: {
-                    l33t: 'Avoid predictable letter substitutions like \'@\' for \'a\'.',
-                    reverseWords: 'Avoid reversed spellings of common words.',
-                    allUppercase: 'Capitalize some, but not all letters.',
-                    capitalization: 'Capitalize more than the first letter.',
-                    dates: 'Avoid dates and years that are associated with you.',
-                    recentYears: 'Avoid recent years.',
-                    associatedYears: 'Avoid years that are associated with you.',
-                    sequences: 'Avoid common character sequences.',
-                    repeated: 'Avoid repeated words and characters.',
-                    longerKeyboardPattern: 'Use longer keyboard patterns and change typing direction multiple times.',
-                    anotherWord: 'Add more words that are less common.',
-                    useWords: 'Use multiple words, but avoid common phrases.',
-                    noNeed: 'You can create strong passwords without using symbols, numbers, or uppercase letters.',
-                    pwned: 'If you use this password elsewhere, you should change it.'
-                }
-            }
+const englishPasswordCheckLocalization = {
+  language: { code: "en", name: "English" },
+  keys: {
+    tstdl: {
+      passwordCheck: {
+        warnings: {
+          straightRow: "Straight rows of keys on your keyboard are easy to guess.",
+          keyPattern: "Short keyboard patterns are easy to guess.",
+          simpleRepeat: 'Repeated characters like "aaa" are easy to guess.',
+          extendedRepeat: 'Repeated character patterns like "abcabcabc" are easy to guess.',
+          sequences: 'Common character sequences like "abc" are easy to guess.',
+          recentYears: "Recent years are easy to guess.",
+          dates: "Dates are easy to guess.",
+          topTen: "This is a heavily used password.",
+          topHundred: "This is a frequently used password.",
+          common: "This is a commonly used password.",
+          similarToCommon: "This is similar to a commonly used password.",
+          wordByItself: "Single words are easy to guess.",
+          namesByThemselves: "Single names or surnames are easy to guess.",
+          commonNames: "Common names and surnames are easy to guess.",
+          userInputs: "There should not be any personal or page related data.",
+          pwned: "Your password was exposed by a data breach on the Internet (https://haveibeenpwned.com/passwords)."
+        },
+        suggestions: {
+          l33t: "Avoid predictable letter substitutions like '@' for 'a'.",
+          reverseWords: "Avoid reversed spellings of common words.",
+          allUppercase: "Capitalize some, but not all letters.",
+          capitalization: "Capitalize more than the first letter.",
+          dates: "Avoid dates and years that are associated with you.",
+          recentYears: "Avoid recent years.",
+          associatedYears: "Avoid years that are associated with you.",
+          sequences: "Avoid common character sequences.",
+          repeated: "Avoid repeated words and characters.",
+          longerKeyboardPattern: "Use longer keyboard patterns and change typing direction multiple times.",
+          anotherWord: "Add more words that are less common.",
+          useWords: "Use multiple words, but avoid common phrases.",
+          noNeed: "You can create strong passwords without using symbols, numbers, or uppercase letters.",
+          pwned: "If you use this password elsewhere, you should change it."
         }
-    },
-    enums: []
+      }
+    }
+  },
+  enums: []
 };

package/pdf/index.js

@@ -1 +1,18 @@
-export * from './pdf.service.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pdf_exports = {};
+module.exports = __toCommonJS(pdf_exports);
+__reExport(pdf_exports, require("./pdf.service.js"), module.exports);

package/pdf/pdf.service.d.ts

@@ -2,8 +2,8 @@ import { BrowserContextController } from '../browser/browser-context-controller.
 import type { BrowserControllerArgument } from '../browser/browser-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
-import type { Injectable } from '../container/index.js';
-import { resolveArgumentType } from '../container/index.js';
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
 import { LogLevel } from '../logger/level.js';
 import { Logger } from '../logger/logger.js';
 import type { TemplateField } from '../templates/index.js';
@@ -39,7 +39,7 @@ export type PdfServiceOptions = {
 export type PdfServiceArgument = PdfServiceOptions & {
     browserControllerArgument: BrowserControllerArgument;
 };
-export declare class PdfService implements Injectable<PdfServiceArgument> {
+export declare class PdfService implements Resolvable<PdfServiceArgument> {
     private readonly templateService;
     private readonly browserController;
     private readonly logger;