@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/cjs/utils/object.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.empty = empty;
+exports.forwardStatics = forwardStatics;
+exports.get = get;
+exports.has = has;
+exports.remove = remove;
+exports.set = set;
+
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+
+var _isNumber2 = _interopRequireDefault(require("lodash/isNumber"));
+
+var _values2 = _interopRequireDefault(require("lodash/values"));
+
+var _unset2 = _interopRequireDefault(require("lodash/unset"));
+
+var _toPath2 = _interopRequireDefault(require("lodash/toPath"));
+
+var _has2 = _interopRequireDefault(require("lodash/has"));
+
+var _set2 = _interopRequireDefault(require("lodash/set"));
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pathToArrayElem = path => {
+  const pathArray = (0, _toPath2.default)(path); // internal-issues:673
+
+  const justNumber = (0, _isNumber2.default)(path) && pathArray.length === 1;
+  return justNumber ? false : Number.isInteger(+pathArray[pathArray.length - 1]);
+};
+
+function isEmptyObject(target) {
+  /**
+   *  var a = {};
+   *  var b = { c: undefined }
+   *  var d = {
+   *      e: function(){},
+   *      f: Symbol(''),
+   *  }
+   *  the result of JSON.stringify(a/b/d) are same: '{}'
+   *  We can use the above features to remove keys with empty values in Form
+   *  But we cannot use JSON.stringify() directly, because if the input parameter of JSON.stringify includes fiberNode, it will cause an TypeError: 'Converting circular structure to JSON'
+   *  So we have to mock it's behavior, also, the form value cannot have Symbol or function type, it can be ignored
+   */
+  if (!(0, _isObject2.default)(target)) {
+    return false;
+  } else {
+    const valuesOfTarget = (0, _values2.default)(target); // values(a)  ->   []
+    // values(b)  ->   [undefined]
+
+    if (!valuesOfTarget.length) {
+      return true; // like target: {}
+    } else {
+      return valuesOfTarget.every(item => typeof item === 'undefined');
+    }
+  }
+}
+
+function cleanup(obj, path) {
+  let pull = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+  if (path.length === 0) {
+    return;
+  }
+
+  const target = (0, _get2.default)(obj, path); // remove undefined from array
+  // if (Array.isArray(target) && pull) {
+  //     // only remove undefined form array from right to left
+  //     // Remove undefined from right to left
+  //     let lastIndex = findLastIndex(target, item => !isUndefined(item));
+  //     lodashRemove(target, (value, index, array) => index > lastIndex);
+  // }
+  // Delete object if its empty
+  // eslint-disable-next-line
+
+  if (Array.isArray(target) && target.every(e => e == null)) {
+    (0, _unset2.default)(obj, path);
+  } else if (isEmptyObject(target)) {
+    (0, _unset2.default)(obj, path);
+  } // Recur
+
+
+  cleanup(obj, path.slice(0, path.length - 1), pull);
+}
+
+function empty(object) {
+  return (0, _values2.default)(object).length === 0;
+}
+
+function get(object, path) {
+  return (0, _get2.default)(object, path);
+}
+
+function remove(object, path) {
+  (0, _unset2.default)(object, path); // a.b => [a, b]
+  // arr[11].a => [arr, 11, a]
+
+  let pathArray = (0, _toPath2.default)(path);
+  pathArray = pathArray.slice(0, pathArray.length - 1);
+  cleanup(object, pathArray, false);
+}
+
+function set(object, path, value, allowEmpty) {
+  if (allowEmpty) {
+    return (0, _set2.default)(object, path, value);
+  }
+
+  if (value !== undefined) {
+    return (0, _set2.default)(object, path, value);
+  } else {
+    // If the path is to an array leaf then we want to set to undefined
+    // 将数组的叶子节点置为undefined时，例如 a.b[0]  a.b[1]  a.b[99]
+    if (pathToArrayElem(path) && get(object, path) !== undefined) {
+      (0, _set2.default)(object, path, undefined);
+      let pathArray = (0, _toPath2.default)(path);
+      pathArray = pathArray.slice(0, pathArray.length - 1);
+      cleanup(object, pathArray, false);
+    } else if (!pathToArrayElem(path) && get(object, path) !== undefined) {
+      // Only delete the field if it needs to be deleted and its not a path to an array ( array leaf )
+      // eg:
+
+      /*
+          When the non-array leaf node is set to undefined
+          for example: a.b.c
+      */
+      remove(object, path);
+    }
+  }
+}
+
+function has(object, path) {
+  return (0, _has2.default)(object, path);
+}
+/**
+ * set static properties from `srcObj` to `obj`
+ * @param {object|Function} obj
+ * @param {object|Function} srcObj
+ * @returns {object|Function}
+ */
+
+
+function forwardStatics(obj, srcObj) {
+  if (obj && (typeof obj === 'function' || typeof obj === 'object') && srcObj && (typeof srcObj === 'function' || typeof srcObj === 'object')) {
+    Object.entries(srcObj).forEach(_ref => {
+      let [key, value] = _ref;
+      obj[key] = value;
+    });
+  }
+
+  return obj;
+}

package/lib/cjs/utils/set.d.ts

@@ -0,0 +1,7 @@
+export declare function copySet<T = unknown>(setA: Iterable<T>): Set<T>;
+/**
+ * Set deduplicate
+ * @param {*} setA
+ * @param {*} setB
+ */
+export declare function pullAll(setA: Iterable<any>, setB: Iterable<any>): Iterable<any>;

package/lib/cjs/utils/set.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copySet = copySet;
+exports.pullAll = pullAll;
+
+var _isSet2 = _interopRequireDefault(require("lodash/isSet"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* istanbul ignore next */
+function copySet(setA) {
+  return new Set(setA);
+}
+/**
+ * Set deduplicate
+ * @param {*} setA
+ * @param {*} setB
+ */
+
+
+function pullAll(setA, setB) {
+  if (setA === setB) {
+    setB = copySet(setB);
+  }
+
+  if ((0, _isSet2.default)(setA) && setA.size && (0, _isSet2.default)(setB) && setB.size) {
+    for (const item of setB) {
+      if (setA.has(item)) {
+        setA.delete(item);
+      }
+    }
+
+    return setA;
+  }
+
+  return setA;
+}

package/lib/cjs/utils/shallowEqualObjects.d.ts

@@ -0,0 +1,5 @@
+export default function shallowEqualObjects(objA: {
+    [key: string]: any;
+}, objB: {
+    [key: string]: any;
+}): boolean;

package/lib/cjs/utils/shallowEqualObjects.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = shallowEqualObjects;
+
+function shallowEqualObjects(objA, objB) {
+  if (objA === objB) {
+    return true;
+  }
+
+  if (!objA || !objB) {
+    return false;
+  }
+
+  const aKeys = Object.keys(objA);
+  const bKeys = Object.keys(objB);
+  const len = aKeys.length;
+
+  if (bKeys.length !== len) {
+    return false;
+  }
+
+  for (let i = 0; i < len; i++) {
+    const key = aKeys[i];
+
+    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/lib/cjs/utils/touchPolyfill.d.ts

@@ -0,0 +1,2 @@
+declare const touchEventPolyfill: (touch: any, touchEvent: any) => any;
+export default touchEventPolyfill;

package/lib/cjs/utils/touchPolyfill.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _warning = _interopRequireDefault(require("./warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const touchEventPolyfill = (touch, touchEvent) => {
+  /* Touch is the first point of multi-touch. In order to minimize the change of slider code to support touch,
+  some methods that will be used on touchEvent are mounted on the multi-touch Touch object.*/
+  // polyfill for firefox
+  if (!globalThis.Touch || !(touch instanceof Touch)) {
+    return touch;
+  }
+
+  const keysNeedPolyfill = ['stopPropagation', 'preventDefault'];
+  keysNeedPolyfill.forEach(key => {
+    let value = touchEvent[key];
+
+    if (value) {
+      if (typeof value === 'function') {
+        // bind 'this' for function of touchEvent running in Touch Point Object
+        value = function () {
+          return touchEvent[key](...arguments);
+        };
+      }
+
+      if (touch[key]) {
+        (0, _warning.default)(true, `"The key ${key}" exist in Touch.`);
+      } else {
+        touch[key] = value;
+      }
+    }
+  });
+  return touch;
+};
+
+var _default = touchEventPolyfill;
+exports.default = _default;

package/lib/cjs/utils/type.d.ts

@@ -0,0 +1,31 @@
+export declare type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+export declare type Motion<P extends Record<string, any> = any> = boolean | MotionObject | MotionFunction<P>;
+export declare type MotionFunction<P> = (props: P) => MotionObject;
+export interface MotionObject {
+    [x: string]: any;
+    children?: any | ((props: MotionChildrenProps) => any);
+    willEnter?: () => void;
+    didEnter?: () => void;
+    willLeave?: () => void;
+    didLeave?: () => void;
+    onStart?: () => void;
+    onRest?: () => void;
+    state?: string;
+}
+export interface MotionChildrenProps {
+    animateCls?: string;
+    animateStyle?: {
+        animationTimingFunction?: string;
+        animationName?: string;
+        animationDuration?: number | string;
+        animationDelay?: number | string;
+        animationIterationCount?: number | string;
+        animationDirection?: 'alternate' | 'normal';
+        animationFillMode?: string;
+    };
+    animateEvents?: {
+        onAnimationIteration?: (...args: any[]) => void;
+        onAnimationStart?: (...args: any[]) => void;
+        onAnimationEnd?: (...args: any[]) => void;
+    };
+}

package/lib/cjs/utils/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/cjs/utils/uuid.d.ts

@@ -0,0 +1,18 @@
+export default function getUuid(prefix: string): string;
+declare function getUuidv4(): string;
+/**
+ * Get a random id with prefix, it not strictly guarantee id uniqueness
+ *
+ * Note: the return value of getUuid is too long, we need a short one
+ *
+ * @example
+ * getUuidShort({ prefix: 'semi' }) => 'semi-46dinzc'
+ * getUuidShort({ prefix: '' }) => '0eer2i0'
+ * getUuidShort({ prefix: 'semi', length: 4 }) => 'semi-8jts'
+ */
+declare function getUuidShort(options?: GetUuidShortOptions): string;
+interface GetUuidShortOptions {
+    prefix?: string;
+    length?: number;
+}
+export { getUuid, getUuidv4, getUuidShort };

package/lib/cjs/utils/uuid.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUuid = exports.default = getUuid;
+exports.getUuidShort = getUuidShort;
+exports.getUuidv4 = getUuidv4;
+
+function getUuid(prefix) {
+  return `${prefix}-${new Date().getTime()}-${Math.random()}`;
+} // https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
+
+
+function getUuidv4() {
+  var _a, _b;
+
+  try {
+    // @ts-ignore
+    return (_b = (_a = crypto === null || crypto === void 0 ? void 0 : crypto.randomUUID) === null || _a === void 0 ? void 0 : _a.call(crypto)) !== null && _b !== void 0 ? _b : String(1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (Number(c) ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> Number(c) / 4).toString(16));
+  } catch (err) {
+    return getUuid('semi');
+  }
+}
+/**
+ * Get a random id with prefix, it not strictly guarantee id uniqueness
+ *
+ * Note: the return value of getUuid is too long, we need a short one
+ *
+ * @example
+ * getUuidShort({ prefix: 'semi' }) => 'semi-46dinzc'
+ * getUuidShort({ prefix: '' }) => '0eer2i0'
+ * getUuidShort({ prefix: 'semi', length: 4 }) => 'semi-8jts'
+ */
+
+
+function getUuidShort() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const {
+    prefix = '',
+    length = 7
+  } = options;
+  const characters = '0123456789abcdefghijklmnopqrstuvwxyz';
+  const total = characters.length;
+  let randomId = '';
+
+  for (let i = 0; i < length; i++) {
+    const random = Math.floor(Math.random() * total);
+    randomId += characters.charAt(random);
+  }
+
+  return prefix ? `${prefix}-${randomId}` : randomId;
+}

package/lib/cjs/utils/warning.d.ts

@@ -0,0 +1 @@
+export default function warning(flag: boolean, info: string): void;

package/lib/cjs/utils/warning.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = warning;
+
+function warning(flag, info) {
+  if (flag) {
+    console.warn(`Warning: ${info}`);
+  }
+}

package/lib/es/anchor/constants.d.ts

@@ -0,0 +1,11 @@
+declare const cssClasses: {
+    PREFIX: string;
+};
+declare const strings: {
+    readonly SIZE: readonly ["small", "default"];
+    readonly SLIDE_COLOR: readonly ["primary", "tertiary", "muted"];
+    readonly MAX_WIDTH: "200px";
+    readonly MAX_HEIGHT: "750px";
+    readonly POSITION_SET: readonly ["top", "topLeft", "topRight", "left", "leftTop", "leftBottom", "right", "rightTop", "rightBottom", "bottom", "bottomLeft", "bottomRight", "leftTopOver", "rightTopOver"];
+};
+export { cssClasses, strings };

package/lib/es/anchor/constants.js

@@ -0,0 +1,12 @@
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const cssClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-anchor`
+};
+const strings = {
+  SIZE: ['small', 'default'],
+  SLIDE_COLOR: ['primary', 'tertiary', 'muted'],
+  MAX_WIDTH: '200px',
+  MAX_HEIGHT: '750px',
+  POSITION_SET: ['top', 'topLeft', 'topRight', 'left', 'leftTop', 'leftBottom', 'right', 'rightTop', 'rightBottom', 'bottom', 'bottomLeft', 'bottomRight', 'leftTopOver', 'rightTopOver']
+};
+export { cssClasses, strings };

package/lib/es/anchor/foundation.d.ts

@@ -0,0 +1,40 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface AnchorAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    addLink: (link: string) => void;
+    removeLink: (link: string) => void;
+    setChildMap: (value: Record<string, Set<string>>) => void;
+    setScrollHeight: (heigh: string) => void;
+    setSlideBarTop: (height: number) => void;
+    setClickLink: (value: boolean) => void;
+    setActiveLink: (link: string, cb: () => void) => void;
+    setClickLinkWithCallBack: (value: boolean, link: string, cb: (link: string) => void) => void;
+    getContainer: () => HTMLElement | Window;
+    getContainerBoundingTop: () => number;
+    getLinksBoundingTop: () => number[];
+    getAnchorNode: (selector: string) => HTMLElement;
+    getContentNode: (selector: string) => HTMLElement;
+    notifyChange: (currentLink: string, previousLink: string) => void;
+    notifyClick: (e: any, link: string) => void;
+    canSmoothScroll: () => boolean;
+}
+export default class AnchorFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<AnchorAdapter<P, S>, P, S> {
+    constructor(adapter: AnchorAdapter<P, S>);
+    init: () => void;
+    destroy: () => void;
+    addLink: (link: string) => void;
+    removeLink: (link: string) => void;
+    setActiveLink: (link: string, prevLink: string, shouldNotify?: boolean) => void;
+    setScrollHeight: () => void;
+    updateScrollHeight: (prevState: any, state: any) => void;
+    setChildMap: () => void;
+    updateChildMap: (prevState: any, state: any) => void;
+    getLinksTop: () => number[];
+    handleScroll: () => void;
+    handleClick: (e: any, link: string, shouldNotify?: boolean) => void;
+    handleClickLink: () => void;
+    _getLinkToMap: (link: any, parents: string[], linkMap: {
+        [key: string]: Set<string>;
+    }) => void;
+    _scrollIntoView: (link: string) => void;
+    _setActiveSlide: () => void;
+}