@cntrl-site/sdk-nextjs 0.3.0 → 0.4.1

package/src/utils/ArticleRectManager/ArticleRectObserver.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from '../EventEmitter';
+
+interface EventMap {
+  'scroll': undefined;
+  'resize': undefined;
+}
+
+export class ArticleRectObserver extends EventEmitter<EventMap> {
+  private resizeObserver: ResizeObserver;
+  private articleWidth: number = 0;
+  private scrollPos: number = window.scrollY;
+  private animationFrame: number = NaN;
+
+  constructor() {
+    super();
+    this.resizeObserver = new ResizeObserver(this.handleResize);
+  }
+
+  get scroll(): number {
+    return this.scrollPos;
+  }
+
+  get width(): number {
+    return this.articleWidth;
+  }
+
+  private setScroll(scroll: number) {
+    this.scrollPos = scroll;
+  }
+
+  start(el: HTMLElement) {
+    this.resizeObserver.observe(el);
+    const onScroll = () => {
+      this.handleScroll(window.scrollY);
+      if (!isNaN(this.animationFrame)) return;
+      this.animationFrame = window.requestAnimationFrame(() => {
+        this.animationFrame = NaN;
+        this.emit('scroll', undefined);
+      });
+    };
+    window.addEventListener('scroll', onScroll);
+    return () => {
+      this.resizeObserver.unobserve(el);
+      window.removeEventListener('scroll', onScroll);
+      if (!isNaN(this.animationFrame)) {
+        window.cancelAnimationFrame(this.animationFrame);
+        this.animationFrame = NaN;
+      }
+    };
+  }
+
+  private handleScroll = (scroll: number) => {
+    this.setScroll(scroll / this.articleWidth);
+  };
+
+  private handleResize: ResizeObserverCallback = (entries: ResizeObserverEntry[]) => {
+    const [entry] = entries;
+    if (!entry) return;
+    const element = entry.target;
+    if (!(element instanceof HTMLElement)) return;
+    this.notify(element);
+    this.emit('resize', undefined);
+  };
+
+  private notify(el: HTMLElement) {
+    const elBoundary = el.getBoundingClientRect();
+    this.articleWidth = elBoundary.width;
+  }
+}

package/src/utils/ArticleRectManager/useArticleRectObserver.ts

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+import { ArticleRectObserver } from './ArticleRectObserver';
+
+export const useArticleRectObserver = (el?: HTMLElement | null) => {
+  const [articleRectObserver, setArticleRectObserver] = useState<ArticleRectObserver | null>(null);
+
+  useEffect(() => {
+    setArticleRectObserver(new ArticleRectObserver());
+  }, []);
+
+  useEffect(() => {
+    if (!el || !articleRectObserver) return;
+    return articleRectObserver.start(el);
+  }, [el, articleRectObserver]);
+
+  return articleRectObserver;
+};

package/src/utils/EventEmitter.ts

@@ -0,0 +1,41 @@
+export type Listener<P> = (payload: P) => void;
+type Listeners<EventMap> = {
+  [E in keyof (EventMap)]?: Listener<EventMap[E]>[];
+};
+
+export abstract class EventEmitter<EventMap> {
+  protected listeners: Listeners<EventMap> = {};
+
+  on<E extends (keyof EventMap)>(
+    event: E,
+    listener: Listener<EventMap[E]>
+  ): () => void {
+    if (!Array.isArray(this.listeners[event])) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event]?.push(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+
+  off<E extends (keyof EventMap)>(
+    event: E,
+    listener: Listener<EventMap[E]>
+  ): void {
+    const filtered = this.listeners[event]?.filter(l => l !== listener);
+    this.listeners[event] = filtered && filtered.length > 0 ? filtered : undefined;
+  }
+
+  protected emit<E extends (keyof EventMap)>(event: E, payload: EventMap[E]): void {
+    const listeners = this.listeners[event];
+    if (!Array.isArray(listeners)) return;
+    for (const listener of listeners) {
+      try {
+        listener(payload);
+      } catch (error) {
+        console.error(error instanceof Error ? error.stack : error);
+      }
+    }
+  }
+}

package/src/utils/binSearchInsertAt.ts

@@ -0,0 +1,33 @@
+type CompareFn<L, R> = (lhs: L, rhs: R) => number;
+type InsertStrategy<T> = (list: T[], item: T, compare: CompareFn<T, T>) => number;
+
+export function binSearchInsertAt<T, K>(list: T[], item: K, compare: CompareFn<K, T>): number {
+  switch (list.length) {
+    case 0: return 0;
+    case 1: return compare(item, list[0]) < 0 ? 0 : 1;
+  }
+  let start = 0;
+  let end = list.length;
+  let pivot: number;
+  let cmpResult: number;
+  while (start < end) {
+    pivot = start + Math.floor((end - start) / 2);
+    cmpResult = compare(item, list[pivot]);
+    if (cmpResult === 0) return pivot + 1;
+    if (cmpResult < 0) {
+      end = pivot;
+    }
+    if (cmpResult > 0) {
+      start = pivot + 1;
+    }
+  }
+  if (start >= list.length) return list.length;
+  return compare(item, list[start]) < 0 ? start : start + 1;
+}
+
+export function createInsert<T>(start: InsertStrategy<T>, compare: CompareFn<T, T>): (list: T[], item: T) => void {
+  return (list: T[], item: T): void => {
+    const pos = start(list, item, compare);
+    list.splice(pos, 0, item);
+  };
+}

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,15 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="HtmlUnknownAttribute" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="myValues">
-        <value>
-          <list size="1">
-            <item index="0" class="java.lang.String" itemvalue="jsx" />
-          </list>
-        </value>
-      </option>
-      <option name="myCustomValuesEnabled" value="true" />
-    </inspection_tool>
-  </profile>
-</component>