@gtkx/react 1.2.2 → 1.4.0

package/src/reconciler/signals.ts

@@ -1,25 +1,67 @@
+import * as GObject from "@gtkx/gi/gobject";
 import { getSignalBaseName, type SignalHandler } from "@gtkx/runtime";
-import { camelCase } from "@gtkx/utils";
+import { getOrInsert, toCamelIdentifier } from "@gtkx/utils";
 import type { HandlerRecord, SignalTarget } from "./node.js";
 import { type TypeInfo, typeInfoFor } from "./metadata.js";
 
+type NotifyBinding = { property: string | null };
+
+const NOTIFY_SIGNAL = "notify";
 const NOTIFY_DETAIL_PREFIX = "notify::";
-const writeState: { depth: number } = { depth: 0 };
+const pendingWrites: (string | null)[] = [];
+const canonicalNames: Map<string, string> = new Map();
 
-const isApplyingWrite = (): boolean => writeState.depth > 0;
+const isApplyingWrite = (): boolean => pendingWrites.length > 0;
+const canonicalName = (property: string): string => getOrInsert(canonicalNames, property, toCamelIdentifier);
 
-const applyWrite = <T>(write: () => T): T => {
-    writeState.depth += 1;
+const runWrite = <T>(property: string | null, write: () => T): T => {
+    pendingWrites.push(property === null ? null : canonicalName(property));
 
     try {
         return write();
     } finally {
-        writeState.depth = Math.max(0, writeState.depth - 1);
+        pendingWrites.pop();
     }
 };
 
-const getNotifyProperty = (signal: string): string | null =>
-    signal.startsWith(NOTIFY_DETAIL_PREFIX) ? camelCase(signal.slice(NOTIFY_DETAIL_PREFIX.length)) : null;
+const applyWrite = <T>(property: string, write: () => T): T => runWrite(property, write);
+const applyMutation = <T>(write: () => T): T => runWrite(null, write);
+
+const notifyBindingFor = (signal: string): NotifyBinding | null => {
+    if (signal === NOTIFY_SIGNAL) {
+        return { property: null };
+    }
+
+    if (!signal.startsWith(NOTIFY_DETAIL_PREFIX)) {
+        return null;
+    }
+
+    return { property: canonicalName(signal.slice(NOTIFY_DETAIL_PREFIX.length)) };
+};
+
+const notifiedProperty = (notify: NotifyBinding, args: unknown[]): string | null => {
+    if (notify.property !== null) {
+        return notify.property;
+    }
+
+    const [pspec] = args;
+
+    return pspec instanceof GObject.ParamSpec ? canonicalName(pspec.getName()) : null;
+};
+
+const isSuppressedNotify = (notify: NotifyBinding, args: unknown[]): boolean => {
+    const notified = notifiedProperty(notify, args);
+
+    return notified === null || pendingWrites.includes(null) || pendingWrites.includes(notified);
+};
+
+const isSuppressed = (record: HandlerRecord, notify: NotifyBinding | null, args: unknown[]): boolean => {
+    if (!record.isBlockable || !isApplyingWrite()) {
+        return false;
+    }
+
+    return notify === null || isSuppressedNotify(notify, args);
+};
 
 const isBlockableSignal = (info: TypeInfo, signal: string): boolean =>
     info.userEventSignals.has(getSignalBaseName(signal));
@@ -27,20 +69,23 @@ const isBlockableSignal = (info: TypeInfo, signal: string): boolean =>
 const invokeHandler = (
     target: SignalTarget,
     record: HandlerRecord,
-    notifyProperty: string | null,
+    notify: NotifyBinding | null,
     args: unknown[],
-): unknown =>
-    notifyProperty === null
+): unknown => {
+    const property = notify?.property ?? null;
+
+    return property === null
         ? record.handler(...args, target.object)
-        : record.handler(Reflect.get(target.object, notifyProperty), target.object);
+        : record.handler(Reflect.get(target.object, property), target.object);
+};
 
-const wrapHandler = (target: SignalTarget, record: HandlerRecord, notifyProperty: string | null): SignalHandler =>
+const wrapHandler = (target: SignalTarget, record: HandlerRecord, notify: NotifyBinding | null): SignalHandler =>
     (...args: unknown[]): unknown => {
-        if (record.isBlockable && isApplyingWrite()) {
+        if (isSuppressed(record, notify, args)) {
             return undefined;
         }
 
-        return target.dispatch(() => invokeHandler(target, record, notifyProperty, args));
+        return target.dispatch(() => invokeHandler(target, record, notify, args));
     };
 
 const connectHandler = (target: SignalTarget, prop: string, signal: string, handler: SignalHandler): void => {
@@ -57,9 +102,8 @@ const connectHandler = (target: SignalTarget, prop: string, signal: string, hand
     }
 
     const isBlockable = isBlockableSignal(typeInfoFor(target.typeName), signal);
-    const notifyProperty = getNotifyProperty(signal);
     const record: HandlerRecord = { signal, handler, wrapped: (): undefined => undefined, isBlockable };
-    record.wrapped = wrapHandler(target, record, notifyProperty);
+    record.wrapped = wrapHandler(target, record, notifyBindingFor(signal));
     target.object.on(signal, record.wrapped);
     target.handlers.set(prop, record);
 };
@@ -84,6 +128,7 @@ const disconnectAllHandlers = (target: SignalTarget): void => {
 };
 
 export {
+    applyMutation,
     applyWrite,
     connectHandler,
     disconnectHandler,

package/src/reconciler/style.ts

@@ -0,0 +1,84 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import { attachParsingErrorLogger, registerProviderForDefaultDisplay, scopedRule } from "@gtkx/css/internal";
+import { STYLE_PROVIDER_PRIORITY_APPLICATION } from "@gtkx/gi/gtk";
+import { createLogger, type Logger } from "@gtkx/utils";
+import { applyWrite } from "./signals.js";
+
+type StyleSlot = { provider: Gtk.CssProvider; className: string; css: string };
+
+const CLASS_PREFIX = "gtkx-s";
+const CSS_CLASSES_PROP = "cssClasses";
+const STYLE_PRIORITY = STYLE_PROVIDER_PRIORITY_APPLICATION + 1;
+const log: Logger = createLogger("react");
+const styles: WeakMap<Gtk.Widget, StyleSlot> = new WeakMap();
+const pool: StyleSlot[] = [];
+const counter: { next: number } = { next: 0 };
+
+const reclaimed: FinalizationRegistry<StyleSlot> = new FinalizationRegistry((slot) => {
+    pool.push(slot);
+});
+
+const createSlot = (): StyleSlot => {
+    counter.next += 1;
+    const provider = registerProviderForDefaultDisplay({ priority: STYLE_PRIORITY, followsPreferences: false });
+    attachParsingErrorLogger(provider, log, "a style prop");
+
+    return { provider, className: `${CLASS_PREFIX}${counter.next.toString()}`, css: "" };
+};
+
+const styleClass = (widget: Gtk.Widget): string | null => styles.get(widget)?.className ?? null;
+
+const releaseStyle = (widget: Gtk.Widget): void => {
+    const slot = styles.get(widget);
+
+    if (slot === undefined) {
+        return;
+    }
+
+    styles.delete(widget);
+    reclaimed.unregister(widget);
+
+    applyWrite(CSS_CLASSES_PROP, () => {
+        widget.removeCssClass(slot.className);
+    });
+
+    pool.push(slot);
+};
+
+const ensureSlot = (widget: Gtk.Widget): StyleSlot => {
+    const existing = styles.get(widget);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    const slot = pool.pop() ?? createSlot();
+    styles.set(widget, slot);
+    reclaimed.register(widget, slot, widget);
+
+    applyWrite(CSS_CLASSES_PROP, () => {
+        widget.addCssClass(slot.className);
+    });
+
+    return slot;
+};
+
+const applyStyle = (widget: Gtk.Widget, style: unknown): string | null => {
+    if (typeof style !== "object" || style === null) {
+        releaseStyle(widget);
+
+        return null;
+    }
+
+    const slot = ensureSlot(widget);
+    const css = scopedRule(slot.className, style);
+
+    if (css !== slot.css) {
+        slot.css = css;
+        slot.provider.loadFromString(css);
+    }
+
+    return slot.className;
+};
+
+export { applyStyle, CSS_CLASSES_PROP, releaseStyle, styleClass };

package/src/reconciler/text.ts

@@ -5,7 +5,7 @@ import { drain, indexBeforeOrEnd } from "@gtkx/utils";
 import type { ContentChild, ContentKind, ElementNode, ParentNode, TextNode } from "./node.js";
 import type { Props } from "./registry.js";
 import { ELEMENT_KIND, TEXT_KIND } from "./node.js";
-import { applyWrite } from "./signals.js";
+import { applyMutation } from "./signals.js";
 
 type OffsetResult = { wasFound: boolean; offset: number };
 
@@ -320,7 +320,7 @@ const rebuildBuffer = (node: ElementNode): void => {
         return;
     }
 
-    applyWrite(() => {
+    applyMutation(() => {
         buffer.setText("", -1);
         const build: BufferBuild = { buffer, view: node.bufferView, marks: [] };
         insertContent(build, node.content);
@@ -385,7 +385,7 @@ const didUpdateTextSurgically = (host: ElementNode, node: TextNode, oldText: str
 
     const start = located.offset;
 
-    applyWrite(() => {
+    applyMutation(() => {
         buffer.delete(buffer.getIterAtOffset(start), buffer.getIterAtOffset(start + charLength(oldText)));
         buffer.insert(buffer.getIterAtOffset(start), newText, -1);
     });

package/src/utils/accessible-props.ts

@@ -201,42 +201,50 @@ function buildRelation(relation: Gtk.AccessibleRelation, type: AccessibleValueTy
     };
 }
 
+const initValue = (gtype: GObject.Type, populate: (value: GObject.Value) => void): GObject.Value => {
+    const value = new GObject.Value();
+    value.init(gtype);
+    populate(value);
+
+    return value;
+};
+
 const buildValue = (descriptor: AccessibleDescriptor, jsValue: unknown): GObject.Value => {
     switch (descriptor.type) {
         case "string": {
-            return GObject.buildValue(GObject.TYPE_STRING, (v) => {
+            return initValue(GObject.TYPE_STRING, (v) => {
                 v.setString(jsValue as string);
             });
         }
         case "boolean": {
-            return GObject.buildValue(GObject.TYPE_BOOLEAN, (v) => {
+            return initValue(GObject.TYPE_BOOLEAN, (v) => {
                 v.setBoolean(jsValue as boolean);
             });
         }
         case "optionalBoolean": {
-            return GObject.buildValue(GObject.TYPE_INT, (v) => {
+            return initValue(GObject.TYPE_INT, (v) => {
                 v.setInt(jsValue === true ? 1 : 0);
             });
         }
         case "int": {
-            return GObject.buildValue(GObject.TYPE_INT, (v) => {
+            return initValue(GObject.TYPE_INT, (v) => {
                 v.setInt(jsValue as number);
             });
         }
         case "double": {
-            return GObject.buildValue(GObject.TYPE_DOUBLE, (v) => {
+            return initValue(GObject.TYPE_DOUBLE, (v) => {
                 v.setDouble(jsValue as number);
             });
         }
         case "object": {
-            return GObject.buildValue(GObject.TYPE_OBJECT, (v) => {
+            return initValue(GObject.TYPE_OBJECT, (v) => {
                 v.setObject(jsValue as GObject.Object | null);
             });
         }
         case "list": {
             const list = Gtk.AccessibleList.newFromList(jsValue as Gtk.Accessible[]);
 
-            return GObject.buildValue(Gtk.AccessibleList.prototype.__type__, (v) => {
+            return initValue(Gtk.AccessibleList.prototype.__type__, (v) => {
                 v.setBoxed(list);
             });
         }