@3dsource/utils 1.0.8 → 1.0.10

package/{lib/predicates/where.d.ts → src/lib/predicates/where.ts}

@@ -1,4 +1,6 @@
+import { textForSearch } from './textForSearch';
 import type { TruthyTypesOf } from 'rxjs';
+
 /**
  * Creates a predicate function to filter records from a collection based on specified criteria.
  *
@@ -42,5 +44,33 @@ import type { TruthyTypesOf } from 'rxjs';
  * ensuring the function is only used with object types. This generic approach allows for flexible usage
  * with various record structures.
  */
-export declare function where<T extends object>(criteria: Partial<TruthyTypesOf<T>>, caseSensitive?: boolean): (record: T) => boolean;
-export declare function whereNot<T extends object>(criteria: Partial<TruthyTypesOf<T>>, caseSensitive?: boolean): (record: T) => boolean;
+
+export function where<T extends object>(
+  criteria: Partial<TruthyTypesOf<T>>,
+  caseSensitive = false,
+): (record: T) => boolean {
+  const preComputedEntries = Object.entries(criteria)
+    .filter(([, value]) => value !== undefined)
+    .map(([key, value]) => [key, textForSearch(value, caseSensitive)] as const);
+
+  return (record: T): boolean => {
+    return (
+      preComputedEntries.length > 0 &&
+      preComputedEntries.every(([key, criterionValue]) => {
+        return (
+          textForSearch(record[key as keyof T] ?? '', caseSensitive) ===
+          criterionValue
+        );
+      })
+    );
+  };
+}
+export function whereNot<T extends object>(
+  criteria: Partial<TruthyTypesOf<T>>,
+  caseSensitive = false,
+): (record: T) => boolean {
+  const whereFunc = where(criteria, caseSensitive);
+  return (record: T) => {
+    return !whereFunc(record);
+  };
+}

package/src/lib/rxjs/leadingTrailingDebounceTime.ts

@@ -0,0 +1,86 @@
+import type { SchedulerLike, Subscriber, Subscription } from 'rxjs';
+import { asyncScheduler, Observable, timer } from 'rxjs';
+
+/**
+ * Emits the most recent value emitted by the source Observable after a
+ * specified time span has passed without another source emission.
+ *
+ * This is a combination of `debounceTime` and `auditTime` operators.
+ *
+ * The leading value is emitted immediately, and trailing values are debounced.
+ *
+ * @param dueTime The time to wait before emitting the last value.
+ * @param scheduler The scheduler to use for the timeout.
+ * @returns A function that returns an Observable that mirrors the source Observable, but applies the specified debouncing.
+ */
+export function leadingTrailingDebounceTime<T>(
+  dueTime: number,
+  scheduler: SchedulerLike = asyncScheduler,
+): (source: Observable<T>) => Observable<T> {
+  return (source: Observable<T>) =>
+    new Observable<T>((subscriber: Subscriber<T>) => {
+      let hasValue = false;
+      let lastValue: T | null = null;
+      let timerSubscription: Subscription | null = null;
+      let leading = true; // Controls whether we emit immediately.
+
+      const clearTimer = () => {
+        if (timerSubscription) {
+          timerSubscription.unsubscribe();
+          timerSubscription = null;
+        }
+      };
+
+      const resetValues = () => {
+        hasValue = false;
+        lastValue = null;
+        leading = true; // Reset so the next new value is immediate.
+      };
+
+      const emitLastValue = () => {
+        if (hasValue && lastValue !== null) {
+          subscriber.next(lastValue);
+          resetValues();
+        }
+      };
+
+      const sourceSubscription = source.subscribe({
+        next: (value) => {
+          // If we are "leading", emit immediately and switch leading off
+          if (leading) {
+            subscriber.next(value);
+            leading = false;
+            timerSubscription = timer(dueTime, scheduler).subscribe(() => {
+              resetValues();
+              clearTimer();
+            });
+            return;
+          }
+
+          // Otherwise, save the value and start (or restart) timer
+          hasValue = true;
+          lastValue = value;
+          clearTimer();
+          timerSubscription = timer(dueTime, scheduler).subscribe(() => {
+            emitLastValue();
+          });
+        },
+        error: (err: unknown) => {
+          clearTimer();
+          subscriber.error(err);
+        },
+        complete: () => {
+          // If there is a pending emission, emit it before completing
+          clearTimer();
+          emitLastValue();
+          subscriber.complete();
+        },
+      });
+
+      // Cleanup logic
+      return () => {
+        clearTimer();
+        sourceSubscription.unsubscribe();
+      };
+    });
+}

package/{lib/rxjs/smoothTransition.d.ts → src/lib/rxjs/smoothTransition.ts}

@@ -1,4 +1,8 @@
 import type { Observable } from 'rxjs';
+import { animationFrameScheduler, interval } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { clampf, lerp } from '../math';
+
 /**
  * Creates an observable that emits values transitioning smoothly from the start value to the end value over a specified duration.
  * The transition is performed using linear interpolation (lerp) and clamped to the range [0, 1].
@@ -8,4 +12,18 @@ import type { Observable } from 'rxjs';
  * @param {number} duration - The duration of the transition in milliseconds.
  * @returns {Observable<number>} An observable that emits the interpolated values from start to end over the specified duration.
  */
-export declare const smoothTransition: (start: number, end: number, duration: number) => Observable<number>;
+export const smoothTransition = (
+  start: number,
+  end: number,
+  duration: number,
+): Observable<number> => {
+  const startTime = animationFrameScheduler.now();
+  return interval(0, animationFrameScheduler).pipe(
+    map(() => {
+      const elapsed = (animationFrameScheduler.now() - startTime) / duration;
+      return clampf(0, 1, elapsed);
+    }),
+    distinctUntilChanged(),
+    map((fraction) => lerp(start, end, fraction)),
+  );
+};

package/src/lib/rxjs/tapLog.ts

@@ -0,0 +1,13 @@
+import { tap } from 'rxjs/operators';
+import type { Observable } from 'rxjs';
+import { Logger } from '../dev';
+import { COLOR_CODES } from '../constants';
+
+export const tapLog =
+  <T>(text: string, ...args: any): ((source: Observable<T>) => Observable<T>) =>
+  (source: Observable<T>) =>
+    source.pipe(
+      tap((data) => {
+        Logger.colored(...COLOR_CODES.TAP_LOG, text, data, ...args);
+      }),
+    );

package/src/lib/strings/pad.ts

@@ -0,0 +1,18 @@
+/**
+ * Adds required number of symbols before input
+ * @param input input string
+ * @param size amount of total symbols
+ * @param symbol filler
+ * @returns string
+ */
+export function pad(
+  input: number | string,
+  size: number,
+  symbol = '0',
+): string {
+  let s = input + '';
+  while (s.length < size) {
+    s = symbol + s;
+  }
+  return s.slice(-size);
+}

package/tsconfig.lib.json

@@ -0,0 +1,13 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": ["**/*.spec.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,11 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}