@slickgrid-universal/utils 4.0.2 → 4.2.0

package/src/nodeExtend.ts

@@ -0,0 +1,131 @@
+/* eslint-disable guard-for-in */
+/**
+ * This extend function is a reimplementation of the npm package `extend` (also named `node-extend`).
+ * The reason for the reimplementation was mostly because the original project is not ESM compatible
+ * and written with old ES6 IIFE syntax, the goal was to reimplement and fix these old syntax and build problems.
+ * e.g. it used `var` everywhere, it used `arguments` to get function arguments, ...
+ *
+ * The previous lib can be found here at this Github link:
+ *     https://github.com/justmoon/node-extend
+ * With an MIT licence that and can be found at
+ *     https://github.com/justmoon/node-extend/blob/main/LICENSE
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+const toStr = Object.prototype.toString;
+const defineProperty = Object.defineProperty;
+const gOPD = Object.getOwnPropertyDescriptor;
+
+const isArray = function isArray(arr: any) {
+  if (typeof Array.isArray === 'function') {
+    return Array.isArray(arr);
+  }
+  /* istanbul ignore next */
+  return toStr.call(arr) === '[object Array]';
+};
+
+const isPlainObject = function isPlainObject(obj: any) {
+  if (!obj || toStr.call(obj) !== '[object Object]') {
+    return false;
+  }
+
+  const hasOwnConstructor = hasOwn.call(obj, 'constructor');
+  const hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+  // Not own constructor property must be Object
+  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+    return false;
+  }
+
+  // Own properties are enumerated firstly, so to speed up, if last one is own, then all properties are own.
+  let key;
+  for (key in obj) { /**/ }
+
+  return typeof key === 'undefined' || hasOwn.call(obj, key);
+};
+
+// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
+const setProperty = function setProperty(target: any, options: any) {
+  if (defineProperty && options.name === '__proto__') {
+    defineProperty(target, options.name, {
+      enumerable: true,
+      configurable: true,
+      value: options.newValue,
+      writable: true
+    });
+  } else {
+    target[options.name] = options.newValue;
+  }
+};
+
+// Return undefined instead of __proto__ if '__proto__' is not an own property
+const getProperty = function getProperty(obj: any, name: string) {
+  if (name === '__proto__') {
+    if (!hasOwn.call(obj, name)) {
+      return void 0;
+    } else if (gOPD) {
+      // In early versions of node, obj['__proto__'] is buggy when obj has __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
+      return gOPD(obj, name)!.value;
+    }
+  }
+
+  return obj[name];
+};
+
+export function extend<T = any>(...args: any[]): T {
+  let options;
+  let name;
+  let src;
+  let copy;
+  let copyIsArray;
+  let clone;
+  let target = args[0];
+  let i = 1;
+  const length = args.length;
+  let deep = false;
+
+  // Handle a deep copy situation
+  if (typeof target === 'boolean') {
+    deep = target;
+    target = args[1] || {};
+    // skip the boolean and the target
+    i = 2;
+  }
+  if (target === null || target === undefined || (typeof target !== 'object' && typeof target !== 'function')) {
+    target = {};
+  }
+
+  for (; i < length; ++i) {
+    options = args[i];
+    // Only deal with non-null/undefined values
+    if (options !== null && options !== undefined) {
+      // Extend the base object
+      for (name in options) {
+        src = getProperty(target, name);
+        copy = getProperty(options, name);
+
+        // Prevent never-ending loop
+        if (target !== copy) {
+          // Recurse if we're merging plain objects or arrays
+          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+            if (copyIsArray) {
+              copyIsArray = false;
+              clone = src && isArray(src) ? src : [];
+            } else {
+              clone = src && isPlainObject(src) ? src : {};
+            }
+
+            // Never move original objects, clone them
+            setProperty(target, { name, newValue: extend(deep, clone, copy) });
+
+            // Don't bring in undefined values
+          } else if (typeof copy !== 'undefined') {
+            setProperty(target, { name, newValue: copy });
+          }
+        }
+      }
+    }
+  }
+
+  // Return the modified object
+  return target;
+};

package/src/stripTagsUtil.ts

@@ -0,0 +1,193 @@
+/**
+ * This stripTags function is a lib that already existed
+ * but was not TypeScript and ESM friendly.
+ * So I ported the code into the project and removed any old code like IE11 that we don't need for our project.
+ * I also accept more input types without throwing, the code below accepts `string | number | boolean | HTMLElement` while original code only accepted string.
+ *
+ * The previous lib can be found here at this Github link:
+ *     https://github.com/ericnorris/striptags/
+ * With an MIT licence that and can be found at
+ *     https://github.com/ericnorris/striptags/blob/main/LICENSE
+ */
+
+import { isNumber } from './utils';
+
+const STATE_PLAINTEXT = Symbol('plaintext');
+const STATE_HTML = Symbol('html');
+const STATE_COMMENT = Symbol('comment');
+const ALLOWED_TAGS_REGEX = /<(\w*)>/g;
+const NORMALIZE_TAG_REGEX = /<\/?([^\s\/>]+)/;
+
+interface Context {
+  allowable_tags: Set<string | null>;
+  tag_replacement: string;
+  state: symbol;
+  tag_buffer: string;
+  depth: number;
+  in_quote_char: string;
+}
+
+export function stripTags(htmlText: string | number | boolean | HTMLElement, allowableTags?: string | string[], tagReplacement?: string) {
+
+  /** main init function that will be executed when calling the global function */
+  function init(html: string | number | boolean | HTMLElement, allowable_tags?: string | string[], tag_replacement?: string) {
+    // number/boolean should be accepted but converted to string and returned on the spot
+    // since there's no html tags to be found but we still expect a string output
+    if (typeof html !== 'string' && (isNumber(html) || typeof html === 'boolean')) {
+      return String(html);
+    }
+    if (html instanceof HTMLElement) {
+      html = html.innerHTML;
+    }
+    if (typeof html !== 'string' && html !== undefined && html !== null) {
+      throw new TypeError(`'html' parameter must be a string`);
+    }
+
+    return striptags_internal(
+      html || '',
+      init_context(allowable_tags || '', tag_replacement || '')
+    );
+  }
+
+  function init_context(allowable_tags: string | string[], tag_replacement: string): Context {
+    return {
+      allowable_tags: parse_allowable_tags(allowable_tags),
+      tag_replacement,
+      state: STATE_PLAINTEXT,
+      tag_buffer: '',
+      depth: 0,
+      in_quote_char: ''
+    };
+  }
+
+  function striptags_internal(html: string, context: Context): string {
+    const allowable_tags = context.allowable_tags;
+    const tag_replacement = context.tag_replacement;
+
+    let state = context.state;
+    let tag_buffer = context.tag_buffer;
+    let depth = context.depth;
+    let in_quote_char = context.in_quote_char;
+    let output = '';
+
+    for (let idx = 0, length = html.length; idx < length; idx++) {
+      const char = html[idx];
+
+      if (state === STATE_PLAINTEXT) {
+        switch (char) {
+          case '<':
+            state = STATE_HTML;
+            tag_buffer += char;
+            break;
+          default:
+            output += char;
+            break;
+        }
+      } else if (state === STATE_HTML) {
+        switch (char) {
+          case '<':
+            // ignore '<' if inside a quote
+            if (in_quote_char) {
+              break;
+            }
+            // we're seeing a nested '<'
+            depth++;
+            break;
+          case '>':
+            // ignore '>' if inside a quote
+            if (in_quote_char) {
+              break;
+            }
+            // something like this is happening: '<<>>'
+            if (depth) {
+              depth--;
+              break;
+            }
+            // this is closing the tag in tag_buffer
+            in_quote_char = '';
+            state = STATE_PLAINTEXT;
+            tag_buffer += '>';
+
+            if (allowable_tags.has(normalize_tag(tag_buffer))) {
+              output += tag_buffer;
+            } else {
+              output += tag_replacement;
+            }
+            tag_buffer = '';
+            break;
+          case '"':
+          case '\'':
+            // catch both single and double quotes
+            if (char === in_quote_char) {
+              in_quote_char = '';
+            } else {
+              in_quote_char = in_quote_char || char;
+            }
+            tag_buffer += char;
+            break;
+          case '-':
+            if (tag_buffer === '<!-') {
+              state = STATE_COMMENT;
+            }
+            tag_buffer += char;
+            break;
+          case ' ':
+          case '\n':
+            if (tag_buffer === '<') {
+              state = STATE_PLAINTEXT;
+              output += '< ';
+              tag_buffer = '';
+              break;
+            }
+            tag_buffer += char;
+            break;
+          default:
+            tag_buffer += char;
+            break;
+        }
+      } else if (state === STATE_COMMENT) {
+        switch (char) {
+          case '>':
+            if (tag_buffer.slice(-2) === '--') {
+              // close the comment
+              state = STATE_PLAINTEXT;
+            }
+            tag_buffer = '';
+            break;
+          default:
+            tag_buffer += char;
+            break;
+        }
+      }
+    }
+
+    // save the context for future iterations
+    context.state = state;
+    context.tag_buffer = tag_buffer;
+    context.depth = depth;
+    context.in_quote_char = in_quote_char;
+    return output;
+  }
+
+  function parse_allowable_tags(allowable_tags: string | string[]): Set<string | null> {
+    let tag_set = new Set<string>();
+
+    if (typeof allowable_tags === 'string') {
+      let match;
+      while ((match = ALLOWED_TAGS_REGEX.exec(allowable_tags))) {
+        tag_set.add(match[1]);
+      }
+    } else if (typeof allowable_tags[Symbol.iterator] === 'function') {
+      tag_set = new Set(allowable_tags);
+    }
+    return tag_set;
+  }
+
+  function normalize_tag(tag_buffer: string) {
+    const match = NORMALIZE_TAG_REGEX.exec(tag_buffer);
+    return match ? match[1].toLowerCase() : null;
+  }
+
+  // init
+  return init(htmlText, allowableTags, tagReplacement);
+}

package/src/types/htmlElementPosition.interface.ts

@@ -0,0 +1,6 @@
+export interface HtmlElementPosition {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './htmlElementPosition.interface';
+export * from './infer.type';

package/src/types/infer.type.ts

@@ -0,0 +1,6 @@
+
+/* eslint-disable @typescript-eslint/indent */
+export type InferDOMType<T> =
+  T extends CSSStyleDeclaration ? Partial<CSSStyleDeclaration> :
+  T extends infer R ? R : any;
+/* eslint-enable @typescript-eslint/indent */