@punks/backend-core 0.0.76 → 0.0.78

package/dist/cjs/types/utils/encoding.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare const encodeUtf8: (value: Uint8Array) => string;
+export declare const decodeUtf8: (value: string) => Buffer;
+export declare const encodeBase64: (value: Uint8Array) => string;
+export declare const decodeBase64: (value: string) => Buffer;

package/dist/cjs/types/utils/html.d.ts

@@ -0,0 +1,61 @@
+type QuoteCharacter = '"' | "'";
+export interface StateMachineOptions {
+    readonly allowedTags?: Set<string>;
+    readonly disallowedTags?: Set<string>;
+    readonly tagReplacementText: string;
+    readonly encodePlaintextTagDelimiters: boolean;
+}
+export type StateTransitionFunction = (next: State) => void;
+export interface State {
+    consume(character: string, transition: StateTransitionFunction): string;
+}
+type InPlaintextStateTransitionFunction = (next: InTagNameState) => void;
+export declare class InPlaintextState implements State {
+    private readonly options;
+    constructor(options: StateMachineOptions);
+    consume(character: string, transition: InPlaintextStateTransitionFunction): string;
+}
+export declare const enum TagMode {
+    Allowed = 0,
+    Disallowed = 1
+}
+type InTagNameStateTransitionFunction = (next: InPlaintextState | InTagState<TagMode.Allowed> | InTagState<TagMode.Disallowed> | InCommentState) => void;
+export declare class InTagNameState implements State {
+    private readonly options;
+    private nameBuffer;
+    private isClosingTag;
+    constructor(options: StateMachineOptions);
+    consume(character: string, transition: InTagNameStateTransitionFunction): string;
+    private isNameBufferAnAllowedTag;
+}
+type InTagStateTransitionFunction<T extends TagMode> = (next: InPlaintextState | InQuotedStringInTagState<T>) => void;
+export declare class InTagState<T extends TagMode> implements State {
+    readonly mode: T;
+    private readonly options;
+    constructor(mode: T, options: StateMachineOptions);
+    consume(character: string, transition: InTagStateTransitionFunction<T>): string;
+}
+type InQuotedStringInTagStateTransitionFunction<T extends TagMode> = (next: InTagState<T>) => void;
+export declare class InQuotedStringInTagState<T extends TagMode> implements State {
+    readonly mode: T;
+    readonly quoteCharacter: QuoteCharacter;
+    private readonly options;
+    constructor(mode: T, quoteCharacter: QuoteCharacter, options: StateMachineOptions);
+    consume(character: string, transition: InQuotedStringInTagStateTransitionFunction<T>): string;
+}
+type InCommentStateTransitionFunction = (next: InPlaintextState) => void;
+export declare class InCommentState implements State {
+    private readonly options;
+    private consecutiveHyphens;
+    constructor(options: StateMachineOptions);
+    consume(character: string, transition: InCommentStateTransitionFunction): string;
+}
+export declare const DefaultStateMachineOptions: StateMachineOptions;
+export declare class StateMachine {
+    private state;
+    private transitionFunction;
+    constructor(partialOptions?: Partial<StateMachineOptions>);
+    consume(text: string): string;
+}
+export declare function stripTags(text: string, options?: Partial<StateMachineOptions>): string;
+export {};

package/dist/cjs/types/utils/index.d.ts

@@ -6,6 +6,8 @@ export { getDirectoryFilePaths } from "./files";
 export { joinPath, splitPath, ensureDirectory, getDirectoryPath, createDayPath, } from "./paths";
 export * from "./strings";
 export * from "./objects";
+export * from "./encoding";
+export { stripTags } from "./html";
 export { maskVariable } from "./variables";
 export * from "./text";
 export * from "./threading";

package/dist/cjs/types/utils/uid.d.ts

@@ -1 +1,2 @@
 export declare const newUuid: () => string;
+export declare const generateHash: (length: number) => string;

package/dist/esm/index.js

@@ -412,6 +412,200 @@ const jsonSerialize = (obj, options) => {
     return JSON.stringify(obj, replacer, spaces);
 };
 
+const encodeUtf8 = (value) => Buffer.from(value).toString("utf-8");
+const decodeUtf8 = (value) => Buffer.from(value, "utf-8");
+const encodeBase64 = (value) => Buffer.from(value).toString("base64");
+const decodeBase64 = (value) => Buffer.from(value, "base64");
+
+// borrowed from https://github.com/ericnorris/striptags
+function isSpace(character) {
+    return (character == " " ||
+        character == "\n" ||
+        character == "\r" ||
+        character == "\t");
+}
+function isQuote(character) {
+    return character == '"' || character == "'";
+}
+const TAG_START = "<";
+const TAG_END = ">";
+const ENCODED_TAG_START = "&lt;";
+const ENCODED_TAG_END = "&gt;";
+class InPlaintextState {
+    constructor(options) {
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == TAG_START) {
+            transition(new InTagNameState(this.options));
+            return "";
+        }
+        else if (character == TAG_END &&
+            this.options.encodePlaintextTagDelimiters) {
+            return ENCODED_TAG_END;
+        }
+        return character;
+    }
+}
+class InTagNameState {
+    constructor(options) {
+        this.options = options;
+        this.nameBuffer = "";
+        this.isClosingTag = false;
+    }
+    consume(character, transition) {
+        if (this.nameBuffer.length == 0) {
+            if (isSpace(character)) {
+                transition(new InPlaintextState(this.options));
+                return ((this.options.encodePlaintextTagDelimiters
+                    ? ENCODED_TAG_START
+                    : "<") + character);
+            }
+            if (character == "/") {
+                this.isClosingTag = true;
+                return "";
+            }
+        }
+        if (isSpace(character)) {
+            if (this.isNameBufferAnAllowedTag()) {
+                transition(new InTagState(0 /* TagMode.Allowed */, this.options));
+                return (TAG_START +
+                    (this.isClosingTag ? "/" : "") +
+                    this.nameBuffer +
+                    character);
+            }
+            else {
+                transition(new InTagState(1 /* TagMode.Disallowed */, this.options));
+                return this.options.tagReplacementText;
+            }
+        }
+        if (character == TAG_START) {
+            this.nameBuffer += ENCODED_TAG_START;
+            return "";
+        }
+        if (character == TAG_END) {
+            transition(new InPlaintextState(this.options));
+            if (this.isNameBufferAnAllowedTag()) {
+                return (TAG_START +
+                    (this.isClosingTag ? "/" : "") +
+                    this.nameBuffer +
+                    character);
+            }
+            else {
+                return this.options.tagReplacementText;
+            }
+        }
+        if (character == "-" && this.nameBuffer == "!-") {
+            transition(new InCommentState(this.options));
+            return "";
+        }
+        this.nameBuffer += character;
+        return "";
+    }
+    isNameBufferAnAllowedTag() {
+        const tagName = this.nameBuffer.toLowerCase();
+        if (this.options.allowedTags) {
+            return this.options.allowedTags.has(tagName);
+        }
+        else if (this.options.disallowedTags) {
+            return !this.options.disallowedTags.has(tagName);
+        }
+        else {
+            return false;
+        }
+    }
+}
+class InTagState {
+    constructor(mode, options) {
+        this.mode = mode;
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == TAG_END) {
+            transition(new InPlaintextState(this.options));
+        }
+        else if (isQuote(character)) {
+            transition(new InQuotedStringInTagState(this.mode, character, this.options));
+        }
+        if (this.mode == 1 /* TagMode.Disallowed */) {
+            return "";
+        }
+        if (character == TAG_START) {
+            return ENCODED_TAG_START;
+        }
+        else {
+            return character;
+        }
+    }
+}
+class InQuotedStringInTagState {
+    constructor(mode, quoteCharacter, options) {
+        this.mode = mode;
+        this.quoteCharacter = quoteCharacter;
+        this.options = options;
+    }
+    consume(character, transition) {
+        if (character == this.quoteCharacter) {
+            transition(new InTagState(this.mode, this.options));
+        }
+        if (this.mode == 1 /* TagMode.Disallowed */) {
+            return "";
+        }
+        if (character == TAG_START) {
+            return ENCODED_TAG_START;
+        }
+        else if (character == TAG_END) {
+            return ENCODED_TAG_END;
+        }
+        else {
+            return character;
+        }
+    }
+}
+class InCommentState {
+    constructor(options) {
+        this.options = options;
+        this.consecutiveHyphens = 0;
+    }
+    consume(character, transition) {
+        if (character == ">" && this.consecutiveHyphens >= 2) {
+            transition(new InPlaintextState(this.options));
+        }
+        else if (character == "-") {
+            this.consecutiveHyphens++;
+        }
+        else {
+            this.consecutiveHyphens = 0;
+        }
+        return "";
+    }
+}
+const DefaultStateMachineOptions = {
+    tagReplacementText: "",
+    encodePlaintextTagDelimiters: true,
+};
+class StateMachine {
+    constructor(partialOptions = {}) {
+        this.state = new InPlaintextState({
+            ...DefaultStateMachineOptions,
+            ...partialOptions,
+        });
+        this.transitionFunction = ((next) => {
+            this.state = next;
+        }).bind(this);
+    }
+    consume(text) {
+        let outputBuffer = "";
+        for (const character of text) {
+            outputBuffer += this.state.consume(character, this.transitionFunction);
+        }
+        return outputBuffer;
+    }
+}
+function stripTags(text, options = {}) {
+    return new StateMachine(options).consume(text);
+}
+
 const maskVariable = (value, unmaskedLength = 4) => value
     ? value.substring(0, unmaskedLength).concat(Array.from(value.substring(unmaskedLength))
         .map(() => "*")
@@ -478,6 +672,13 @@ const newUuid = () => {
         return v.toString(16);
     });
 };
+const generateHash = (length) => {
+    let text = "";
+    const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < length; i++)
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    return text;
+};
 
 function serializeQueryString(obj) {
     let queryString = "";
@@ -31247,5 +31448,5 @@ const processArrayItemMove = (items, input) => {
     }));
 };
 
-export { ConsoleLogger, DatadogLogger, ExcelKeyTransform, FileLogger, Log, LogLevel, MetaSerializationType, addTime, buildObject, buildTree, buildUrl, byField, byFieldDesc, camelToKebabCase, camelToSnakeCase, createDayPath, csvBuild, csvParse, deserializeQueryString, distinct, distinctElements, ensureDirectory, ensureStartSlash, ensureTailingSlash, excelBuild, excelParse, first, flatten, floorDateToSecond, getDirectoryFilePaths, getDirectoryPath, getQueryParameter, groupBy, indexes, isNullOrUndefined, iterate, joinPath, joinUrl, jsonDistinct, jsonSerialize, last, logMemoryUsage, mapAsync, mapOrThrow, maskVariable, mergeDeep, multipleSplit, newUuid, notNull, notUndefined, pluralize, processArrayDifferences, processArrayItemMove, range, removeUndefinedProps, selectMany, serializeQueryString, sleep, sort, splitPath, subArrays, subtractTime, testInternetConnection, toArrayDict, toCamelCase, toDict, toItemsDict, toItemsMap, toMap, toTitleCase, trim$1 as trim, trimEnd, trimStart, updateQueryParameters };
+export { ConsoleLogger, DatadogLogger, ExcelKeyTransform, FileLogger, Log, LogLevel, MetaSerializationType, addTime, buildObject, buildTree, buildUrl, byField, byFieldDesc, camelToKebabCase, camelToSnakeCase, createDayPath, csvBuild, csvParse, decodeBase64, decodeUtf8, deserializeQueryString, distinct, distinctElements, encodeBase64, encodeUtf8, ensureDirectory, ensureStartSlash, ensureTailingSlash, excelBuild, excelParse, first, flatten, floorDateToSecond, generateHash, getDirectoryFilePaths, getDirectoryPath, getQueryParameter, groupBy, indexes, isNullOrUndefined, iterate, joinPath, joinUrl, jsonDistinct, jsonSerialize, last, logMemoryUsage, mapAsync, mapOrThrow, maskVariable, mergeDeep, multipleSplit, newUuid, notNull, notUndefined, pluralize, processArrayDifferences, processArrayItemMove, range, removeUndefinedProps, selectMany, serializeQueryString, sleep, sort, splitPath, stripTags, subArrays, subtractTime, testInternetConnection, toArrayDict, toCamelCase, toDict, toItemsDict, toItemsMap, toMap, toTitleCase, trim$1 as trim, trimEnd, trimStart, updateQueryParameters };
 //# sourceMappingURL=index.js.map