evikit 1.0.0

package/bin/evikit-extract.js

@@ -0,0 +1,36 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, globSync, readFileSync, writeFileSync } from "node:fs";
+import { basename } from "node:path";
+
+const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
+const ref = `po/${pkg.name}.pot`;
+spawnSync(
+  "xgettext",
+  [
+    `--copyright-holder=${pkg.author}`,
+    "--from-code=UTF-8",
+    "--no-location",
+    `--output=${ref}`,
+    `--package-name=${pkg.name}`,
+    ...globSync("src/**/*.js"),
+  ],
+  { stdio: "inherit" },
+);
+writeFileSync(ref, readFileSync(ref, "utf-8").replace("CHARSET", "UTF-8"));
+for (const output of globSync("po/*.po")) {
+  if (existsSync(output) && readFileSync(output, "utf-8").trim()) {
+    spawnSync("msgmerge", ["--no-location", "--update", output, ref], {
+      stdio: "inherit",
+    });
+  } else {
+    spawnSync(
+      "msginit",
+      [
+        `--input=${ref}`,
+        `--locale=${basename(output, ".po")}.UTF-8`,
+        `--output-file=${output}`,
+      ],
+      { stdio: "inherit" },
+    );
+  }
+}

package/db.d.ts

@@ -0,0 +1,242 @@
+import type {
+  InferInput,
+  InferMetadata,
+  InferOutput,
+  MetadataAction,
+  ObjectSchema,
+} from "valibot";
+
+export type Db<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+  F extends Flatten<Schema> = Flatten<Schema>,
+> = {
+  [Table in keyof R]: Table extends keyof F & keyof Schema & string
+    ? {
+        delete(where: {
+          [K in keyof Schema[Table]["entries"]]?:
+            | InferOutput<Schema[Table]["entries"][K]>
+            | InferOutput<Schema[Table]["entries"][K]>[];
+        }): void;
+
+        select<W extends Join<R, Table>>(
+          props?: W,
+        ): Select<Schema, R, F, Table, W>[];
+
+        update(query: {
+          set: Partial<InferOutput<Schema[Table]>>;
+          where: {
+            [K in keyof Schema[Table]["entries"]]?:
+              | InferOutput<Schema[Table]["entries"][K]>
+              | InferOutput<Schema[Table]["entries"][K]>[];
+          };
+        }): void;
+
+        upsert(
+          ...values: InferInput<Schema[Table]>[]
+        ): InferOutput<Schema[Table]>[];
+      }
+    : never;
+};
+
+export type Flatten<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+> = {
+  [Self in keyof R]: Self extends string
+    ? UnionToIntersection<
+        {
+          [Own in keyof R[Self]]: Own extends string
+            ? {
+                [Other in keyof R[Self][Own]]: Other extends string
+                  ? R[Self][Own][Other] extends Record<string, { name: string }>
+                    ? {
+                        [
+                          Its in keyof R[Self][Own][Other] as R[Self][Own][Other][Its]["name"]
+                        ]: Its extends string
+                          ? R[Self][Own][Other][Its]
+                          : never;
+                      }
+                    : never
+                  : never;
+              }[keyof R[Self][Own]]
+            : never;
+        }[keyof R[Self]]
+      >
+    : never;
+};
+
+export type Join<Relations, Self extends keyof Relations> = UnionToIntersection<
+  {
+    [Own in keyof Relations[Self]]: Own extends string
+      ? {
+          [Other in keyof Relations[Self][Own]]: Other extends keyof Relations
+            ? {
+                [Its in keyof Relations[Self][Own][Other]]: Its extends string
+                  ? Relations[Self][Own][Other] extends Record<
+                      string,
+                      { name: string }
+                    >
+                    ? {
+                        // Turning this into partial record would cause infinite depth.
+                        // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
+                        with: {
+                          [K in Relations[Self][Own][Other][Its]["name"]]?:
+                            Join<Relations, Other> | true;
+                        };
+                      }
+                    : never
+                  : never;
+              }[keyof Relations[Self][Own][Other]]
+            : never;
+        }[keyof Relations[Self][Own]]
+      : never;
+  }[keyof Relations[Self]]
+>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Relations<Schema extends Record<string, ObjectSchema<any, any>>> = {
+  [Self in keyof Schema]: Self extends string
+    ? OmitExtendsRecordUndefined<{
+        [Own in keyof Schema[Self]["entries"]]: Own extends string
+          ? OmitExtendsRecordUndefined<{
+              [Other in keyof Schema]: Other extends string
+                ? OmitExtendsUndefined<{
+                    [Its in keyof Schema[Other]["entries"]]: Its extends string
+                      ? InferMetadata<Schema[Self]["entries"][Own]> extends {
+                          key: Schema[Other]["entries"][Its];
+                          references: Schema[Other];
+                        }
+                        ? Schema[Other] extends InferMetadata<
+                            Schema[Self]["entries"][Own]
+                          >["references"]
+                          ? Schema[Other]["entries"][Its] extends InferMetadata<
+                              Schema[Self]["entries"][Own]
+                            >["key"]
+                            ? {
+                                Its: Its;
+                                name: Rewrite<Self, Own, Other, Its>;
+                                Other: Other;
+                                Own: Own;
+                                type: "references";
+                              }
+                            : undefined
+                          : undefined
+                        : InferMetadata<Schema[Other]["entries"][Its]> extends {
+                              key: Schema[Self]["entries"][Own];
+                              references: Schema[Self];
+                            }
+                          ? Schema[Self] extends InferMetadata<
+                              Schema[Other]["entries"][Its]
+                            >["references"]
+                            ? Schema[Self]["entries"][Own] extends InferMetadata<
+                                Schema[Other]["entries"][Its]
+                              >["key"]
+                              ? {
+                                  Its: Its;
+                                  name: Rewrite<Self, Own, Other, Its>;
+                                  Other: Other;
+                                  Own: Own;
+                                  type: "referencedBy";
+                                }
+                              : undefined
+                            : undefined
+                          : undefined
+                      : undefined;
+                  }>
+                : undefined;
+            }>
+          : undefined;
+      }>
+    : undefined;
+};
+
+type OmitExtends<T, U> = {
+  [K in keyof T as T[K] extends U ? never : K]: T[K];
+};
+
+type OmitExtendsRecordUndefined<T> = OmitExtends<T, Record<string, undefined>>;
+
+type OmitExtendsUndefined<T> = OmitExtends<T, undefined>;
+
+type Rewrite<
+  Self extends string,
+  Own extends string,
+  Other extends string,
+  Its extends string,
+> =
+  // Image.id, Question.imageId -> Image.Question.
+  Its extends `${Uncapitalize<Self>}${Capitalize<Own>}`
+    ? Other
+    : // Question.quizId, Quiz.id -> Question.Quiz.
+      Own extends `${Uncapitalize<Other>}${Capitalize<Its>}`
+      ? Other
+      : // Quiz.coverId, Image.id -> Quiz.cover.
+        Own extends `${infer R}${Capitalize<Its>}`
+        ? R
+        : // Image.id, Quiz.coverId -> Image.CoverQuiz.
+          Its extends `${infer R}${Capitalize<Own>}`
+          ? `${Capitalize<R>}${Other}`
+          : never;
+
+type Select<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+  F extends Flatten<Schema> = Flatten<Schema>,
+  Table extends keyof F & keyof Schema = keyof F & keyof Schema,
+  W extends Join<R, Table> = Join<R, Table>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+> = W extends { with: any }
+  ? InferOutput<Schema[Table]> & {
+      [K in keyof W["with"]]: K extends keyof F[Table]
+        ? F[Table][K] extends {
+            Other: keyof F & keyof Schema;
+            type: "referencedBy";
+          }
+          ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (W["with"][K] extends { with: any }
+              ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
+              : InferOutput<Schema[F[Table][K]["Other"]]>)[]
+          : F[Table][K] extends {
+                Other: keyof F & keyof Schema;
+                type: "references";
+              }
+            ? | undefined
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              | (W["with"][K] extends { with: any }
+                  ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
+                  : InferOutput<Schema[F[Table][K]["Other"]]>)
+            : never
+        : never;
+    }
+  : never;
+
+// https://www.geeksforgeeks.org/typescript/union-type-to-intersection-type-in-typescript/
+type UnionToIntersection<U> = (
+  U extends object ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+export function flatten<
+  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
+>(relations: Relations<Schema>): Flatten<Schema>;
+
+export function primary(): MetadataAction<any, { primary: true }>; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+export function references<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  R extends { entries: any },
+  K extends keyof R["entries"],
+>(
+  references: R,
+  key: K,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): MetadataAction<any, { key: R["entries"][K]; references: R }>;
+
+export function relations<
+  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
+>(schema: Schema): Relations<Schema>;

package/db.js

@@ -0,0 +1,128 @@
+import { getMetadata, metadata } from "valibot";
+
+/** @type {typeof import('./db.d.ts').flatten} */
+export function flatten(relations) {
+  return /** @type {any} */ (
+    Object.fromEntries(
+      Object.entries(relations).map(([Self, self]) => [
+        Self,
+        Object.fromEntries(
+          Object.values(self)
+            .map((own) =>
+              Object.values(own).map((other) =>
+                Object.values(other).map((its) => [its.name, its]),
+              ),
+            )
+            .flat()
+            .flat(),
+        ),
+      ]),
+    )
+  );
+}
+
+export function primary() {
+  return metadata({ primary: true });
+}
+
+/** @type {typeof import('./db.d.ts').references} */
+export function references(references, key) {
+  return metadata({ key: references.entries[key], references });
+}
+
+/** @type {typeof import('./db.d.ts').relations} */
+export function relations(schema) {
+  return /** @type {any} */ (
+    Object.fromEntries(
+      Object.entries(/** @type {any} */ (schema)).map(([Self, self]) => [
+        Self,
+        Object.fromEntries(
+          Object.entries(self.entries)
+            .map(([Own, own]) => [
+              Own,
+              Object.fromEntries(
+                Object.entries(/** @type {any} */ (schema))
+                  .map(([Other, other]) => [
+                    Other,
+                    Object.fromEntries(
+                      Object.entries(other.entries)
+                        .map(([Its, its]) => {
+                          const ownMetadata =
+                            /** @type {{ key?: string, references: any }} */ (
+                              getMetadata(own)
+                            );
+
+                          const itsMetadata =
+                            /** @type {{ key?: string, references: any }} */ (
+                              getMetadata(its)
+                            );
+                          return [
+                            Its,
+                            ownMetadata.key == its &&
+                            other == ownMetadata.references
+                              ? {
+                                  Its: Its,
+                                  name: rewrite(Self, Own, Other, Its),
+                                  Other: Other,
+                                  Own: Own,
+                                  type: "references",
+                                }
+                              : itsMetadata.key == own &&
+                                  self == itsMetadata.references
+                                ? {
+                                    Its: Its,
+                                    name: rewrite(Self, Own, Other, Its),
+                                    Other: Other,
+                                    Own: Own,
+                                    type: "referencedBy",
+                                  }
+                                : undefined,
+                          ];
+                        })
+                        .filter(([, maybeUndefined]) => maybeUndefined),
+                    ),
+                  ])
+                  .filter(([, maybeRecordUndefined]) =>
+                    Object.values(maybeRecordUndefined).some((value) => value),
+                  ),
+              ),
+            ])
+            .filter(([, maybeRecordUndefined]) =>
+              Object.values(maybeRecordUndefined).some((value) => value),
+            ),
+        ),
+      ]),
+    )
+  );
+}
+
+/** @param {string} input */
+function capitalize(input) {
+  return `${input[0]?.toUpperCase()}${input.slice(1)}`;
+}
+
+/**
+ * @param {string} Self
+ * @param {string} Own
+ * @param {string} Other
+ * @param {string} Its
+ */
+function rewrite(Self, Own, Other, Its) {
+  return Its == `${uncapitalize(Self)}${capitalize(Own)}`
+    ? Other
+    : // Question.quizId, Quiz.id -> Question.Quiz.
+      Own == `${uncapitalize(Other)}${capitalize(Its)}`
+      ? Other
+      : // Quiz.coverId, Image.id -> Quiz.cover.
+        Own.endsWith(capitalize(Its))
+        ? Own.slice(0, -Its.length)
+        : // Image.id, Quiz.coverId -> Image.CoverQuiz.
+          Its.endsWith(capitalize(Own))
+          ? `${capitalize(Its.slice(0, -Own.length))}${Other}`
+          : undefined;
+}
+
+/** @param {string} input */
+function uncapitalize(input) {
+  return `${input[0]?.toLowerCase()}${input.slice(1)}`;
+}

package/eslint.config.js

@@ -0,0 +1,22 @@
+import { includeIgnoreFile } from "@eslint/compat";
+import js from "@eslint/js";
+import prettier from "eslint-config-prettier/flat";
+import perfectionist from "eslint-plugin-perfectionist";
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import { fileURLToPath } from "node:url";
+import ts from "typescript-eslint";
+
+export default defineConfig(
+  includeIgnoreFile(fileURLToPath(new URL("./.gitignore", import.meta.url))),
+  js.configs.recommended,
+  ...ts.configs.strict,
+  ...ts.configs.stylistic,
+  perfectionist.configs["recommended-natural"],
+  prettier,
+  {
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+    },
+  },
+);

package/html-element.d.ts

@@ -0,0 +1,8 @@
+import { ClassAttributes, ComponentChildren, JSX, VNode } from "preact";
+
+export function HTMLElement<T extends keyof JSX.IntrinsicElements>(
+  type: T,
+): (
+  props: (ClassAttributes<HTMLElement> & JSX.IntrinsicElements[T]) | null,
+  ...children: ComponentChildren[]
+) => VNode<ClassAttributes<HTMLElement> & JSX.IntrinsicElements[T]>;

package/html-element.js

@@ -0,0 +1,12 @@
+import { h } from "preact";
+
+/** @param {string} type */
+export function HTMLElement(type) {
+  /**
+   * @param {any} props
+   * @param {import("preact").ComponentChildren[]} children
+   */
+  return function element(props, ...children) {
+    return h(type, props, ...children);
+  };
+}

package/html.js

@@ -0,0 +1,33 @@
+import { HTMLElement } from "./html-element.js";
+
+export const a = HTMLElement("a");
+export const b = HTMLElement("b");
+export const button = HTMLElement("button");
+export const circle = HTMLElement("circle");
+export const dialog = HTMLElement("dialog");
+export const div = HTMLElement("div");
+export const fieldset = HTMLElement("fieldset");
+export const figure = HTMLElement("figure");
+export const form = HTMLElement("form");
+export const header = HTMLElement("header");
+export const h1 = HTMLElement("h1");
+export const h2 = HTMLElement("h2");
+export const h3 = HTMLElement("h3");
+export const h4 = HTMLElement("h4");
+export const h5 = HTMLElement("h5");
+export const h6 = HTMLElement("h6");
+export const i = HTMLElement("i");
+export const img = HTMLElement("img");
+export const input = HTMLElement("input");
+export const label = HTMLElement("label");
+export const li = HTMLElement("li");
+export const main = HTMLElement("main");
+export const ol = HTMLElement("ol");
+export const option = HTMLElement("option");
+export const p = HTMLElement("p");
+export const path = HTMLElement("path");
+export const select = HTMLElement("select");
+export const span = HTMLElement("span");
+export const svg = HTMLElement("svg");
+export const title = HTMLElement("title");
+export const ul = HTMLElement("ul");

package/i18n.js

@@ -0,0 +1,59 @@
+import acceptLanguage from "accept-language";
+import i18n from "gettext.js";
+import { createContext } from "preact";
+import { useContext } from "preact/hooks";
+
+export const Po = {
+  /** @type {Record<string, ReturnType<typeof import("gettext-parser").po.parse>>} */
+  cache: {},
+
+  /** @param {string} lang */
+  async get(lang) {
+    if (!Po.cache[lang] && Po.value) {
+      Po.cache[lang] = await Po.value(lang);
+    }
+    const cache = Po.cache[lang];
+    if (!cache) {
+      throw new Error(lang);
+    }
+    return cache;
+  },
+
+  /** @param {(lang: string) => Promise<ReturnType<typeof import("gettext-parser").po.parse>>} value */
+  set(value) {
+    Po.value = value;
+  },
+
+  /** @type {((lang: string) => Promise<ReturnType<typeof import("gettext-parser").po.parse>>) | undefined} */
+  value: undefined,
+};
+
+/** @param {readonly string[]} langs */
+export async function getI18n(...langs) {
+  const lang = acceptLanguage.get(langs.join(", ")) || "en";
+  if (lang == "en") {
+    return i18n({ locale: lang });
+  }
+  const { headers, translations } = await Po.get(lang);
+  return i18n({ locale: lang }).setMessages(
+    "messages",
+    lang,
+    Object.fromEntries(
+      Object.values(translations[""] || {}).map(({ msgid, msgstr }) => [
+        msgid,
+        msgstr.length == 1 ? /** @type {any} */ (msgstr[0]) : msgstr,
+      ]),
+    ),
+    headers["Plural-Forms"],
+  );
+}
+
+const RawI18n = createContext(
+  /** @type {Awaited<ReturnType<getI18n>>} */ (/** @type {any} */ (undefined)),
+);
+
+export const RawI18nProvider = RawI18n.Provider;
+
+export function useI18n() {
+  return useContext(RawI18n);
+}

package/index.d.ts

@@ -0,0 +1,116 @@
+import type { ClassAttributes, ComponentChildren, JSX, VNode } from "preact";
+
+import i18n from "gettext.js";
+
+import { useApi } from "./use-api.js";
+import { useEnhance } from "./use-enhance.js";
+
+export interface DehydratedState {
+  queries: { queryHash: string; state: QueryState }[];
+}
+
+export interface QueryState {
+  data: any; // eslint-disable-line @typescript-eslint/no-explicit-any
+  dataUpdatedAt: number;
+  error: null | unknown;
+  isInvalidated: boolean;
+  status: "error" | "loading" | "success";
+}
+
+type H<T extends keyof JSX.IntrinsicElements> = (
+  props: (ClassAttributes<HTMLElement> & JSX.IntrinsicElements[T]) | null,
+  ...children: ComponentChildren[]
+) => VNode<ClassAttributes<HTMLElement> & JSX.IntrinsicElements[T]>;
+
+export function dehydrate(
+  queryClient: ReturnType<typeof useQueryClient>,
+  options: {
+    shouldRedactErrors: (error: unknown) => boolean;
+  },
+): DehydratedState;
+
+export function getI18n(...langs: string[]): Promise<i18n.Gettext>;
+
+export function hydrate(
+  App: (props: {
+    dehydratedState?: DehydratedState | undefined;
+    i18n: i18n.Gettext;
+  }) => VNode<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
+  renderTarget: string,
+): Promise<void>;
+
+export function Router({
+  children,
+  dehydratedState,
+  i18n,
+}: {
+  children?: ComponentChildren;
+  dehydratedState?: DehydratedState | undefined;
+  i18n: i18n.Gettext;
+}): VNode<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+export function ssr(
+  App: (props: {
+    dehydratedState?: DehydratedState | undefined;
+    i18n: i18n.Gettext;
+  }) => VNode<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
+  data: { lang?: string; url: string },
+): Promise<{
+  data: {
+    dehydratedState: DehydratedState;
+    lang?: string;
+    url: string;
+  };
+  head: {
+    elements: Set<{
+      props: Record<string, string>;
+      type: string;
+    }>;
+    lang: string;
+    title: string;
+  };
+  html: string;
+  links: Set<string> | undefined;
+}>;
+
+export function useI18n(): i18n.Gettext;
+
+export function useQueryClient(): {
+  invalidateQueries(): void;
+};
+
+export function useStatus(error: unknown): string;
+
+export const a: H<"a">;
+export const b: H<"b">;
+export const button: H<"button">;
+export const circle: H<"circle">;
+export const dialog: H<"dialog">;
+export const div: H<"div">;
+export const fieldset: H<"fieldset">;
+export const figure: H<"figure">;
+export const form: H<"form">;
+export const header: H<"header">;
+export const h1: H<"h1">;
+export const h2: H<"h2">;
+export const h3: H<"h3">;
+export const h4: H<"h4">;
+export const h5: H<"h5">;
+export const h6: H<"h6">;
+export const i: H<"i">;
+export const img: H<"img">;
+export const input: H<"input">;
+export const label: H<"label">;
+export const li: H<"li">;
+export const main: H<"main">;
+export const ol: H<"ol">;
+export const option: H<"option">;
+export const p: H<"p">;
+export const path: H<"path">;
+export const select: H<"select">;
+export const span: H<"span">;
+export const svg: H<"svg">;
+export const title: H<"title">;
+export const ul: H<"ul">;
+
+export { useApi, useEnhance };