max/memorium
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

fix: soo many lint errors

Browse Source
This commit is contained in:
Max Richter
2025-11-03 00:03:27 +01:00
parent c13420c3ab
commit 696082250d
41 changed files with 373 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
lib/helpers.ts
View File

@@ -102,17 +102,14 @@ export function debounce<T extends (...args: Parameters<T>) => void>(
}
export function parseRating(rating: string | number) {
if (typeof rating === "string") {
try {
const res = parseInt(rating);
if (!Number.isNaN(res)) return res;
} catch (_e) {
// This is okay
}
return rating.length / 2;
if (typeof rating == "number") return rating;
try {
const res = parseInt(rating);
if (!Number.isNaN(res)) return res;
} catch (_e) {
// This is okay
}
return rating;
return rating.length / 2;
}
export async function convertOggToMp3(

328
lib/hooks/useDebouncedCallback.ts
View File

@@ -1,285 +1,93 @@
import { useEffect, useMemo, useRef } from "preact/hooks";
export interface CallOptions {
/**
* Controls if the function should be invoked on the leading edge of the timeout.
*/
leading?: boolean;
/**
* Controls if the function should be invoked on the trailing edge of the timeout.
*/
trailing?: boolean;
}
type Debounced<T extends (...args: unknown[]) => unknown> =
& ((
...args: Parameters<T>
) => void)
& {
cancel: () => void;
flush: () => void;
pending: () => boolean;
};
export interface Options extends CallOptions {
/**
* The maximum time the given function is allowed to be delayed before it's invoked.
*/
maxWait?: number;
}
export interface ControlFunctions {
/**
* Cancel pending function invocations
*/
cancel: () => void;
/**
* Immediately invoke pending function invocations
*/
flush: () => void;
/**
* Returns `true` if there are any pending function invocations
*/
isPending: () => boolean;
}
/**
* Subsequent calls to the debounced function `debounced.callback` return the result of the last func invocation.
* Note, that if there are no previous invocations it's mean you will get undefined. You should check it in your code properly.
*/
export interface DebouncedState<T extends (...args: any) => ReturnType<T>>
extends ControlFunctions {
(...args: Parameters<T>): ReturnType<T> | undefined;
}
/**
* Creates a debounced function that delays invoking `func` until after `wait`
* milliseconds have elapsed since the last time the debounced function was
* invoked, or until the next browser frame is drawn.
*
* The debounced function comes with a `cancel` method to cancel delayed `func`
* invocations and a `flush` method to immediately invoke them.
*
* Provide `options` to indicate whether `func` should be invoked on the leading
* and/or trailing edge of the `wait` timeout. The `func` is invoked with the
* last arguments provided to the debounced function.
*
* Subsequent calls to the debounced function return the result of the last
* `func` invocation.
*
* **Note:** If `leading` and `trailing` options are `true`, `func` is
* invoked on the trailing edge of the timeout only if the debounced function
* is invoked more than once during the `wait` timeout.
*
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
* until the next tick, similar to `setTimeout` with a timeout of `0`.
*
* If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
* invocation will be deferred until the next frame is drawn (typically about
* 16ms).
*
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
* for details over the differences between `debounce` and `throttle`.
*
* @category Function
* @param {Function} func The function to debounce.
* @param {number} [wait=0]
* The number of milliseconds to delay; if omitted, `requestAnimationFrame` is
* used (if available, otherwise it will be setTimeout(...,0)).
* @param {Object} [options={}] The options object.
* Controls if `func` should be invoked on the leading edge of the timeout.
* @param {boolean} [options.leading=false]
* The maximum time `func` is allowed to be delayed before it's invoked.
* @param {number} [options.maxWait]
* Controls if `func` should be invoked the trailing edge of the timeout.
* @param {boolean} [options.trailing=true]
* @returns {Function} Returns the new debounced function.
* @example
*
* // Avoid costly calculations while the window size is in flux.
* const resizeHandler = useDebouncedCallback(calculateLayout, 150);
* window.addEventListener('resize', resizeHandler)
*
* // Invoke `sendMail` when clicked, debouncing subsequent calls.
* const clickHandler = useDebouncedCallback(sendMail, 300, {
* leading: true,
* trailing: false,
* })
* <button onClick={clickHandler}>click me</button>
*
* // Ensure `batchLog` is invoked once after 1 second of debounced calls.
* const debounced = useDebouncedCallback(batchLog, 250, { 'maxWait': 1000 })
* const source = new EventSource('/stream')
* source.addEventListener('message', debounced)
*
* // Cancel the trailing debounced invocation.
* window.addEventListener('popstate', debounced.cancel)
*
* // Check for pending invocations.
* const status = debounced.pending() ? "Pending..." : "Ready"
*/
export default function useDebouncedCallback<
T extends (...args: any) => ReturnType<T>,
T extends (...args: unknown[]) => unknown,
>(
func: T,
wait?: number,
options?: Options,
): DebouncedState<T> {
const lastCallTime = useRef(null);
const lastInvokeTime = useRef(0);
const timerId = useRef(null);
const lastArgs = useRef<unknown[]>([]);
const lastThis = useRef<unknown>();
const result = useRef<ReturnType<T>>();
const funcRef = useRef(func);
const mounted = useRef(true);
callback: T,
delay: number,
options?: {
/** Call on the leading edge. Default: false */
leading?: boolean;
/** Call on the trailing edge. Default: true */
trailing?: boolean;
},
): Debounced<T> {
const callbackRef = useRef(callback);
const timerRef = useRef<number | null>(null);
const argsRef = useRef<Parameters<T> | null>(null);
// Always use the latest callback without re-creating the debounced fn
useEffect(() => {
funcRef.current = func;
}, [func]);
callbackRef.current = callback;
}, [callback]);
// Bypass `requestAnimationFrame` by explicitly setting `wait=0`.
const useRAF = !wait && wait !== 0 && typeof window !== "undefined";
const leading = !!options?.leading;
const trailing = options?.trailing !== false; // default true
if (typeof func !== "function") {
throw new TypeError("Expected a function");
}
wait = +wait || 0;
options = options || {};
const leading = !!options.leading;
const trailing = "trailing" in options ? !!options.trailing : true; // `true` by default
const maxing = "maxWait" in options;
const maxWait = maxing ? Math.max(+options.maxWait || 0, wait) : null;
useEffect(() => {
mounted.current = true;
return () => {
mounted.current = false;
};
}, []);
// You may have a question, why we have so many code under the useMemo definition.
//
// This was made as we want to escape from useCallback hell and
// not to initialize a number of functions each time useDebouncedCallback is called.
//
// It means that we have less garbage for our GC calls which improves performance.
// Also, it makes this library smaller.
//
// And the last reason, that the code without lots of useCallback with deps is easier to read.
// You have only one place for that.
const debounced = useMemo(() => {
const invokeFunc = (time: number) => {
const args = lastArgs.current;
const thisArg = lastThis.current;
lastArgs.current = lastThis.current = null;
lastInvokeTime.current = time;
return (result.current = funcRef.current.apply(thisArg, args));
};
const startTimer = (pendingFunc: () => void, wait: number) => {
if (useRAF) cancelAnimationFrame(timerId.current);
timerId.current = useRAF
? requestAnimationFrame(pendingFunc)
: setTimeout(pendingFunc, wait);
};
const shouldInvoke = (time: number) => {
if (!mounted.current) return false;
const timeSinceLastCall = time - lastCallTime.current;
const timeSinceLastInvoke = time - lastInvokeTime.current;
// Either this is the first call, activity has stopped and we're at the
// trailing edge, the system time has gone backwards and we're treating
// it as the trailing edge, or we've hit the `maxWait` limit.
return (
!lastCallTime.current ||
timeSinceLastCall >= wait ||
timeSinceLastCall < 0 ||
(maxing && timeSinceLastInvoke >= maxWait)
);
};
const trailingEdge = (time: number) => {
timerId.current = null;
// Only invoke if we have `lastArgs` which means `func` has been
// debounced at least once.
if (trailing && lastArgs.current) {
return invokeFunc(time);
const debounced = useMemo<Debounced<T>>(() => {
const clear = () => {
if (timerRef.current != null) {
clearTimeout(timerRef.current);
timerRef.current = null;
}
lastArgs.current = lastThis.current = null;
return result.current;
};
const timerExpired = () => {
const time = Date.now();
if (shouldInvoke(time)) {
return trailingEdge(time);
const invoke = () => {
const a = argsRef.current;
argsRef.current = null;
if (a) {
callbackRef.current(...a);
}
// https://github.com/xnimorz/use-debounce/issues/97
if (!mounted.current) {
return;
};
const fn = ((...args: Parameters<T>) => {
const shouldCallLeading = leading && timerRef.current == null;
argsRef.current = args;
if (timerRef.current != null) clearTimeout(timerRef.current);
timerRef.current = globalThis.setTimeout(() => {
timerRef.current = null;
if (trailing) invoke();
}, delay);
if (shouldCallLeading) {
// Leading edge call happens immediately
invoke();
}
// Remaining wait calculation
const timeSinceLastCall = time - lastCallTime.current;
const timeSinceLastInvoke = time - lastInvokeTime.current;
const timeWaiting = wait - timeSinceLastCall;
const remainingWait = maxing
? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
: timeWaiting;
}) as Debounced<T>;
// Restart the timer
startTimer(timerExpired, remainingWait);
fn.cancel = () => {
argsRef.current = null;
clear();
};
const func: DebouncedState<T> = (...args: Parameters<T>): ReturnType<T> => {
const time = Date.now();
const isInvoking = shouldInvoke(time);
lastArgs.current = args;
lastThis.current = this;
lastCallTime.current = time;
if (isInvoking) {
if (!timerId.current && mounted.current) {
// Reset any `maxWait` timer.
lastInvokeTime.current = lastCallTime.current;
// Start the timer for the trailing edge.
startTimer(timerExpired, wait);
// Invoke the leading edge.
return leading ? invokeFunc(lastCallTime.current) : result.current;
}
if (maxing) {
// Handle invocations in a tight loop.
startTimer(timerExpired, wait);
return invokeFunc(lastCallTime.current);
}
fn.flush = () => {
if (timerRef.current != null) {
clear();
invoke();
}
if (!timerId.current) {
startTimer(timerExpired, wait);
}
return result.current;
};
func.cancel = () => {
if (timerId.current) {
useRAF
? cancelAnimationFrame(timerId.current)
: clearTimeout(timerId.current);
}
lastInvokeTime.current = 0;
lastArgs.current =
lastCallTime.current =
lastThis.current =
timerId.current =
null;
};
fn.pending = () => timerRef.current != null;
func.isPending = () => {
return !!timerId.current;
};
return fn;
// Recreate only if timing/edge behavior changes
}, [delay, leading, trailing]);
func.flush = () => {
return !timerId.current ? result.current : trailingEdge(Date.now());
};
return func;
}, [leading, maxing, wait, maxWait, trailing, useRAF]);
// Cancel on unmount
useEffect(() => () => debounced.cancel(), [debounced]);
return debounced;
}

6
lib/hooks/useEventListener.ts
View File

@@ -6,7 +6,7 @@ export function useEventListener<T extends Event>(
element: typeof globalThis | HTMLElement = globalThis,
) {
// Create a ref that stores handler
const savedHandler = useRef<(event: Event) => void>();
const savedHandler = useRef<(event: T) => void>();
// Update ref.current value if handler changes.
// This allows our effect below to always get latest handler ...
@@ -27,11 +27,11 @@ export function useEventListener<T extends Event>(
const eventListener = (event: T) => savedHandler?.current?.(event);
// Add event listener
element.addEventListener(eventName, eventListener);
element.addEventListener(eventName, (ev) => eventListener(ev as T));
// Remove event listener on cleanup
return () => {
element.removeEventListener(eventName, eventListener);
element.removeEventListener(eventName, (ev) => eventListener(ev as T));
};
},
[eventName, element], // Re-run if eventName or element changes

4
lib/hooks/useThrottledCallback.ts
View File

@@ -6,7 +6,7 @@ type ThrottleOptions = {
};
const useThrottledCallback = (
callback: (...args: any[]) => void,
callback: (...args: unknown[]) => void,
delay: number,
options: ThrottleOptions = {},
) => {
@@ -24,7 +24,7 @@ const useThrottledCallback = (
};
}, [timer]);
const throttledCallback = (...args: any[]) => {
const throttledCallback = (...args: unknown[]) => {
const now = Date.now();
if (leading && !isLeading) {

17
lib/hooks/useTraceProps.ts
View File

@@ -1,14 +1,17 @@
import { useEffect, useRef } from "preact/hooks";
export function useTraceUpdate(props) {
export function useTraceUpdate(props: Record<string, unknown>) {
const prev = useRef(props);
useEffect(() => {
const changedProps = Object.entries(props).reduce((ps, [k, v]) => {
if (prev.current[k] !== v) {
ps[k] = [prev.current[k], v];
}
return ps;
}, {});
const changedProps = Object.entries(props).reduce(
(ps: Record<string, unknown>, [k, v]) => {
if (prev.current[k] !== v) {
ps[k] = [prev.current[k], v];
}
return ps;
},
{},
);
if (Object.keys(changedProps).length > 0) {
console.log("Changed props:", changedProps);
}

6
lib/image.ts
View File

@@ -134,7 +134,7 @@ async function getLocalImage(
*/
async function storeLocalImage(
url: string,
content: ArrayBuffer,
content: Uint8Array<ArrayBuffer> | ArrayBuffer,
{ width, height }: { width?: number; height?: number } = {},
) {
const isValid = await verifyImage(new Uint8Array(content));
@@ -249,7 +249,7 @@ async function verifyImage(imageBuffer: Uint8Array): Promise<boolean> {
export async function getImageContent(
url: string,
{ width, height }: { width?: number; height?: number } = {},
): Promise<{ content: ArrayBuffer; mimeType: string }> {
): Promise<{ content: Uint8Array<ArrayBuffer>; mimeType: string }> {
log.debug("Getting image content", { url, width, height });
// Check if we have the image metadata in database
@@ -267,8 +267,8 @@ export async function getImageContent(
// Fetch and cache original if needed
if (!originalImage) {
const fetchedImage = await getRemoteImage(url);
await storeLocalImage(url, fetchedImage.buffer);
originalImage = new Uint8Array(fetchedImage.buffer);
await storeLocalImage(url, originalImage);
}
// Resize image

14
lib/marka/schema.ts
View File

@@ -68,6 +68,7 @@ export const ReviewContentSchema = makeContentSchema("Review", {
export const RecipeContentSchema = makeContentSchema("Recipe", {
description: z.string().optional(),
name: z.string().optional(),
reviewRating: ReviewRatingSchema.optional(),
recipeIngredient: z.array(z.string()).optional(),
recipeInstructions: z.array(z.string()).optional(),
totalTime: z.string().optional(),
@@ -124,3 +125,16 @@ export type RecipeResource = z.infer<typeof RecipeSchema> & {
export type GenericResource = z.infer<typeof GenericResourceSchema> & {
image?: typeof imageTable.$inferSelect;
};
export function getNameOfResource(res: GenericResource): string {
if (res.content?._type === "Article" && res.content.headline) {
return res.content.headline;
}
if (res.content?._type === "Review" && res.content.itemReviewed?.name) {
return res.content.itemReviewed.name;
}
if (res.content?._type === "Recipe" && res.content.name) {
return res.content.name;
}
return "Unnamed Resource";
}

10
lib/openai.ts
View File

@@ -1,5 +1,5 @@
import OpenAI from "https://deno.land/x/openai@v4.69.0/mod.ts";
import { zodResponseFormat } from "https://deno.land/x/openai@v4.69.0/helpers/zod.ts";
import OpenAI, { toFile } from "@openai/openai";
import { zodResponseFormat } from "@openai/openai/helpers/zod";
import { OPENAI_API_KEY } from "@lib/env.ts";
import { hashString } from "@lib/helpers.ts";
import { createCache } from "@lib/cache.ts";
@@ -216,7 +216,7 @@ export async function createTags(content: string) {
export async function extractRecipe(content: string) {
if (!openAI) return;
const completion = await openAI.beta.chat.completions.parse({
const completion = await openAI.chat.completions.parse({
model: model,
temperature: 0.1,
messages: [
@@ -234,7 +234,7 @@ export async function extractRecipe(content: string) {
export async function extractArticleMetadata(content: string) {
if (!openAI) return;
const completion = await openAI.beta.chat.completions.parse({
const completion = await openAI.chat.completions.parse({
model: model,
temperature: 0.1,
messages: [
@@ -259,7 +259,7 @@ export async function transcribe(
): Promise<string | undefined> {
if (!openAI) return;
const file = new File([mp3Data], "audio.mp3", {
const file = await toFile(mp3Data, "audio.mp3", {
type: "audio/mpeg",
});

4
lib/parseIngredient.ts
View File

@@ -1,7 +1,7 @@
import {
parseIngredient,
unitsOfMeasure as _unitsOfMeasure,
} from "npm:parse-ingredient";
} from "parse-ingredient";
import { Ingredient, IngredientGroup } from "@lib/recipeSchema.ts";
import { removeMarkdownFormatting } from "@lib/string.ts";
@@ -77,7 +77,7 @@ export function parseIngredients(
};
const unit = ingredient.unit.toLowerCase() as keyof typeof unitsOfMeasure;
if (unit in unitsOfMeasure && unit !== "cup") {
if (unit in unitsOfMeasure) {
ingredient.unit = unitsOfMeasure[unit].short;
}

6
lib/recommendation.ts
View File

@@ -2,9 +2,9 @@ import * as openai from "@lib/openai.ts";
import * as tmdb from "@lib/tmdb.ts";
import { parseRating } from "@lib/helpers.ts";
import { createCache } from "@lib/cache.ts";
import { GenericResource, ReviewResource } from "./marka/schema.ts";
import { ReviewResource } from "./marka/schema.ts";
type RecommendationResource = {
export type RecommendationResource = {
id: string;
type: string;
rating: number;
@@ -96,5 +96,5 @@ export async function getAllRecommendations(): Promise<
> {
const keys = cache.keys();
const res = await Promise.all(keys.map((k) => cache.get(k)));
return res.map((r) => JSON.parse(r));
return res.filter((s) => !!s).map((r) => JSON.parse(r));
}

7
lib/search.ts
View File

@@ -1,8 +1,9 @@
import { resources } from "@lib/resources.ts";
import fuzzysort from "npm:fuzzysort";
import fuzzysort from "fuzzysort";
import { extractHashTags } from "@lib/string.ts";
import { listResources } from "./marka/index.ts";
import { GenericResource } from "./marka/schema.ts";
import { parseRating } from "./helpers.ts";
type ResourceType = keyof typeof resources;
@@ -72,8 +73,8 @@ export async function searchResource(
if (
!(resource.name in results) &&
rating && resource?.content?.reviewRating &&
resource.content?.reviewRating?.ratingValue >= rating
rating && resource.content.reviewRating?.ratingValue &&
parseRating(resource.content.reviewRating.ratingValue) >= rating
) {
results[resource.name] = resource;
}

2
lib/string.ts
View File

@@ -1,5 +1,3 @@
import { resources } from "@lib/resources.ts";
export function formatDate(date: Date): string {
const options = { year: "numeric", month: "long", day: "numeric" } as const;
return new Intl.DateTimeFormat("en-US", options).format(date);

4
lib/types.ts
View File

@@ -1,4 +1,4 @@
import { GenericResource, GenericResourceSchema } from "./marka/schema.ts";
import { GenericResource } from "./marka/schema.ts";
export interface TMDBMovie {
adult: boolean;
@@ -39,7 +39,7 @@ export interface GiteaOauthUser {
preferred_username: string;
email: string;
picture: string;
groups: any;
groups: unknown;
}
export type SearchResult = {

52
lib/webScraper.ts
View File

@@ -11,12 +11,14 @@ export function absolutizeDomUrls(dom: JSDOM, domain: string): void {
const base = toBase(domain);
const rewrite = (selector: string, attr: string) => {
document.querySelectorAll<HTMLElement>(selector).forEach((el) => {
const v = el.getAttribute(attr);
if (!v) return;
const abs = toAbsolute(v, base);
if (abs !== v) el.setAttribute(attr, abs);
});
document.querySelectorAll<HTMLElement>(selector).forEach(
(el: HTMLElement) => {
const v = el.getAttribute(attr);
if (!v) return;
const abs = toAbsolute(v, base);
if (abs !== v) el.setAttribute(attr, abs);
},
);
};
// Common URL attributes
@@ -41,35 +43,35 @@ export function absolutizeDomUrls(dom: JSDOM, domain: string): void {
rewrite("form[action]", "action");
rewrite("video[poster]", "poster");
// srcset (img, source)
document
.querySelectorAll<HTMLElement>("img[srcset], source[srcset]")
.forEach((el) => {
.querySelectorAll("img[srcset], source[srcset]")
.forEach((el: HTMLImageElement) => {
const v = el.getAttribute("srcset");
if (!v) return;
const abs = absolutizeSrcset(v, base);
if (abs !== v) el.setAttribute("srcset", abs);
});
// Inline CSS in style attributes: url(...)
document.querySelectorAll<HTMLElement>("[style]").forEach((el) => {
const v = el.getAttribute("style");
if (!v) return;
const abs = absolutizeCssUrls(v, base);
if (abs !== v) el.setAttribute("style", abs);
});
document.querySelectorAll("[style]").forEach(
(el: HTMLElement) => {
const v = el.getAttribute("style");
if (!v) return;
const abs = absolutizeCssUrls(v, base);
if (abs !== v) el.setAttribute("style", abs);
},
);
// <style> blocks (inline CSS): url(...)
document.querySelectorAll<HTMLStyleElement>("style").forEach((styleEl) => {
const css = styleEl.textContent ?? "";
const abs = absolutizeCssUrls(css, base);
if (abs !== css) styleEl.textContent = abs;
});
document.querySelectorAll("style").forEach(
(styleEl: HTMLStyleElement) => {
const css = styleEl.textContent ?? "";
const abs = absolutizeCssUrls(css, base);
if (abs !== css) styleEl.textContent = abs;
},
);
// <meta http-equiv="refresh" content="5; url=/path">
document
.querySelectorAll<HTMLMetaElement>('meta[http-equiv="refresh" i][content]')
.forEach((meta) => {
.querySelectorAll('meta[http-equiv="refresh" i][content]')
.forEach((meta: HTMLMetaElement) => {
const content = meta.getAttribute("content") || "";
const abs = absolutizeMetaRefresh(content, base);
if (abs !== content) meta.setAttribute("content", abs);