@gtkx/react 1.0.0-rc.1 → 1.0.0-rc.3

package/src/utils/gtype.ts

@@ -1,166 +0,0 @@
-/// <reference types="@gtkx/config/env" />
-
-import { CONSTRUCT_ONLY_PROPS, CONSTRUCT_PROPS, DEFAULT_PROPS, SIGNALS } from "virtual:gtkx-config";
-import * as GObject from "@gtkx/gi/gobject";
-import { getWrapperClass, type TypedClass } from "@gtkx/runtime";
-import { NOTIFY_SIGNAL, propToNotifySignal } from "./notify-name.js";
-
-const NOTIFY_PREFIX = "onNotify";
-
-const resolveNotifySignal = (propName: string): string | null => {
-    if (propName === NOTIFY_PREFIX) return NOTIFY_SIGNAL;
-    if (!propName.startsWith(NOTIFY_PREFIX)) return null;
-    const tail = propName.slice(NOTIFY_PREFIX.length);
-    if (tail.charAt(0) !== tail.charAt(0).toUpperCase()) return null;
-    return propToNotifySignal(tail);
-};
-
-const typeNameChainCache = new Map<bigint, string[]>();
-const interfaceNamesCache = new Map<bigint, string[]>();
-const typeNameSetCache = new Map<bigint, Set<string>>();
-const signalCache = new Map<bigint, Map<string, string | null>>();
-const constructOnlyCache = new Map<bigint, Map<string, boolean>>();
-const defaultPropCache = new Map<bigint, Map<string, DefaultPropLookup>>();
-const constructablePropsCache = new Map<bigint, Set<string>>();
-
-const memoizeGtype = <T>(cache: Map<bigint, T>, gtype: bigint, compute: () => T): T => {
-    const cached = cache.get(gtype);
-    if (cached !== undefined) return cached;
-    const result = compute();
-    cache.set(gtype, result);
-    return result;
-};
-
-const collectTypeNameChain = (gtype: bigint): string[] =>
-    memoizeGtype(typeNameChainCache, gtype, () => {
-        const chain: string[] = [];
-        let current = gtype;
-        while (current !== 0n) {
-            const name = GObject.typeName(current);
-            if (!name) break;
-            chain.push(name);
-            current = GObject.typeParent(current);
-        }
-        return chain;
-    });
-
-const collectInterfaceNames = (gtype: bigint): string[] =>
-    memoizeGtype(interfaceNamesCache, gtype, () => {
-        const names: string[] = [];
-        for (const iface of GObject.typeInterfaces(gtype)) {
-            const name = GObject.typeName(iface);
-            if (name) names.push(name);
-        }
-        return names;
-    });
-
-const typeNamesWithInterfacesCache = new Map<bigint, string[]>();
-
-export const collectTypeNamesWithInterfaces = (gtype: bigint): string[] =>
-    memoizeGtype(typeNamesWithInterfacesCache, gtype, () => [
-        ...collectTypeNameChain(gtype),
-        ...collectInterfaceNames(gtype),
-    ]);
-
-const foldInheritedTable = <R, T>(
-    gtype: bigint,
-    table: Record<string, R>,
-    fold: (accumulator: T, row: R) => T,
-    seed: T,
-): T => {
-    let accumulator = seed;
-    for (const name of collectTypeNameChain(gtype)) {
-        const row = table[name];
-        if (row !== undefined) accumulator = fold(accumulator, row);
-    }
-    return accumulator;
-};
-
-export const foldInheritedTableWithInterfaces = <R, T>(
-    gtype: bigint,
-    table: Record<string, R>,
-    fold: (accumulator: T, row: R) => T,
-    seed: T,
-): T => {
-    let accumulator = foldInheritedTable(gtype, table, fold, seed);
-    for (const name of collectInterfaceNames(gtype)) {
-        const row = table[name];
-        if (row !== undefined) accumulator = fold(accumulator, row);
-    }
-    return accumulator;
-};
-
-export const typeChainIncludes = (gtype: bigint, name: string): boolean =>
-    memoizeGtype(typeNameSetCache, gtype, () => new Set(collectTypeNameChain(gtype))).has(name);
-
-const memoize = <T>(
-    cache: Map<bigint, Map<string, T>>,
-    instance: TypedClass,
-    key: string,
-    compute: (typeNames: string[]) => T,
-): T => {
-    const gtype = instance.__type__;
-    const perGtype = memoizeGtype(cache, gtype, () => new Map<string, T>());
-    const cached = perGtype.get(key);
-    if (cached !== undefined) return cached;
-    const result = compute(collectTypeNameChain(gtype));
-    perGtype.set(key, result);
-    return result;
-};
-
-export const collectConstructableProps = (gtype: bigint): Set<string> =>
-    memoizeGtype(constructablePropsCache, gtype, () =>
-        foldInheritedTable(
-            gtype,
-            CONSTRUCT_PROPS,
-            (collected: Set<string>, props) => {
-                for (const prop of props) collected.add(prop);
-                return collected;
-            },
-            new Set<string>(),
-        ),
-    );
-
-export const isConstructOnlyProp = (instance: TypedClass, key: string): boolean =>
-    memoize(constructOnlyCache, instance, key, (typeNames) => {
-        for (const name of typeNames) {
-            if (CONSTRUCT_ONLY_PROPS[name]?.has(key)) return true;
-        }
-        return false;
-    });
-
-export const resolveSignal = (instance: TypedClass, propName: string): string | null => {
-    const notify = resolveNotifySignal(propName);
-    if (notify) return notify;
-    return memoize(signalCache, instance, propName, (typeNames) => {
-        for (const name of typeNames) {
-            const result = SIGNALS[name]?.[propName];
-            if (result) return result;
-        }
-        return null;
-    });
-};
-
-type DefaultPropLookup = { has: boolean; value: unknown };
-
-const NO_DEFAULT_PROP: DefaultPropLookup = { has: false, value: undefined };
-
-export const resolveDefaultProp = (instance: TypedClass, key: string): DefaultPropLookup =>
-    memoize(defaultPropCache, instance, key, (typeNames) => {
-        for (const name of typeNames) {
-            const table = DEFAULT_PROPS[name];
-            if (table && key in table) return { has: true, value: table[key] };
-        }
-        return NO_DEFAULT_PROP;
-    });
-
-export const requireClassByName = (typeName: string): (new (props: Record<string, unknown>) => GObject.Object) => {
-    const gtype = GObject.typeFromName(typeName);
-    if (gtype === GObject.TYPE_INVALID)
-        throw new Error(
-            `${typeName} is not registered. Import its @gtkx/jsx namespace module (e.g. \`import "@gtkx/jsx/adw"\`) before use.`,
-        );
-    return getWrapperClass(gtype) as new (
-        props: Record<string, unknown>,
-    ) => GObject.Object;
-};

package/src/utils/notify-name.ts

@@ -1,10 +0,0 @@
-import { toCamelCase, toKebabCase } from "@gtkx/utils";
-
-export const NOTIFY_SIGNAL = "notify";
-
-export const NOTIFY_DETAIL_PREFIX = "notify::";
-
-export const propToNotifySignal = (property: string): `notify::${string}` =>
-    `${NOTIFY_DETAIL_PREFIX}${toKebabCase(property)}`;
-
-export const notifyDetailToProp = (detail: string): string => toCamelCase(detail.slice(NOTIFY_DETAIL_PREFIX.length));

package/src/utils/object-prop.ts

@@ -1,13 +0,0 @@
-import * as GObject from "@gtkx/gi/gobject";
-import type { RefObject } from "react";
-
-/**
- * An object accepted by the GObject-aware hooks: a GObject, a ref to one, or a nullish value.
- */
-export type ObjectProp<T extends GObject.Object> = T | RefObject<T | null> | null | undefined;
-
-export const resolveObjectProp = <T extends GObject.Object>(prop: ObjectProp<T>): T | null => {
-    if (!prop) return null;
-    if (prop instanceof GObject.Object) return prop;
-    return prop.current;
-};

package/src/utils/settings-accessor.ts

@@ -1,89 +0,0 @@
-import type * as Gio from "@gtkx/gi/gio";
-import * as GLib from "@gtkx/gi/glib";
-
-type SettingAccessor = {
-    read: (settings: Gio.Settings, key: string) => unknown;
-    write: (settings: Gio.Settings, key: string, value: unknown) => void;
-};
-
-const settingTypeError = (expected: string, value: unknown): TypeError =>
-    new TypeError(`Expected ${expected} for the settings value, got ${typeof value}`);
-
-const expect =
-    <T>(guard: (value: unknown) => value is T, label: string) =>
-    (value: unknown): T => {
-        if (!guard(value)) throw settingTypeError(label, value);
-        return value;
-    };
-
-const expectBoolean = expect((value): value is boolean => typeof value === "boolean", "a boolean");
-
-const expectNumber = expect((value): value is number => typeof value === "number", "a number");
-
-const expectString = expect((value): value is string => typeof value === "string", "a string");
-
-const isStringArray = (value: unknown): value is string[] =>
-    Array.isArray(value) && value.every((entry) => typeof entry === "string");
-
-const expectStringArray = expect(isStringArray, "an array of strings");
-
-const expectVariant = expect((value): value is GLib.Variant => value instanceof GLib.Variant, "a GLib.Variant");
-
-const expectBigInt = (value: unknown): bigint => {
-    if (typeof value === "bigint") return value;
-    if (typeof value === "number") return BigInt(value);
-    throw settingTypeError("a bigint", value);
-};
-
-const STRING_ACCESSOR: SettingAccessor = {
-    read: (settings, key) => settings.getString(key),
-    write: (settings, key, value) => settings.setString(key, expectString(value)),
-};
-
-const STRV_ACCESSOR: SettingAccessor = {
-    read: (settings, key) => settings.getStrv(key),
-    write: (settings, key, value) => settings.setStrv(key, expectStringArray(value)),
-};
-
-const ACCESSORS: Record<string, SettingAccessor> = {
-    b: {
-        read: (settings, key) => settings.getBoolean(key),
-        write: (settings, key, value) => settings.setBoolean(key, expectBoolean(value)),
-    },
-    i: {
-        read: (settings, key) => settings.getInt(key),
-        write: (settings, key, value) => settings.setInt(key, expectNumber(value)),
-    },
-    u: {
-        read: (settings, key) => settings.getUint(key),
-        write: (settings, key, value) => settings.setUint(key, expectNumber(value)),
-    },
-    x: {
-        read: (settings, key) => settings.getInt64(key),
-        write: (settings, key, value) => settings.setInt64(key, expectBigInt(value)),
-    },
-    t: {
-        read: (settings, key) => settings.getUint64(key),
-        write: (settings, key, value) => settings.setUint64(key, expectBigInt(value)),
-    },
-    d: {
-        read: (settings, key) => settings.getDouble(key),
-        write: (settings, key, value) => settings.setDouble(key, expectNumber(value)),
-    },
-    s: STRING_ACCESSOR,
-    as: STRV_ACCESSOR,
-    enum: STRING_ACCESSOR,
-    flags: STRV_ACCESSOR,
-};
-
-const VARIANT_ACCESSOR: SettingAccessor = {
-    read: (settings, key) => settings.getValue(key),
-    write: (settings, key, value) => settings.setValue(key, expectVariant(value)),
-};
-
-export const resolveAccessor = (kind: string | undefined, key: string, schemaId: string): SettingAccessor => {
-    if (kind === undefined) {
-        throw new TypeError(`Key "${key}" is not declared by the GSettings schema "${schemaId}"`);
-    }
-    return ACCESSORS[kind] ?? VARIANT_ACCESSOR;
-};

package/src/utils/wrapper-node-jsx.ts

@@ -1,34 +0,0 @@
-import type * as Gdk from "@gtkx/gi/gdk";
-import type { ReactNode } from "react";
-
-/**
- * Props for a text anchor that embeds child widgets at a position within a text view's buffer.
- */
-export type TextAnchorProps = {
-    /** The character used to represent the embedded widget in the buffer's text. */
-    replacementChar?: string;
-    children?: ReactNode;
-};
-
-/**
- * Props for a node that embeds a `Gdk.Paintable` within a text view's buffer.
- */
-export type TextPaintableProps = {
-    paintable: Gdk.Paintable;
-};
-
-type WrapperNodeElementProps = {
-    kind: string;
-    children?: ReactNode;
-    [key: string]: unknown;
-};
-
-declare global {
-    namespace React {
-        namespace JSX {
-            interface IntrinsicElements {
-                __GTKX_WRAPPER_NODE__: WrapperNodeElementProps;
-            }
-        }
-    }
-}