@gtkx/ffi 0.7.0 → 0.9.0

package/dist/generated/harfbuzz/glyph-info-t.d.ts

@@ -10,6 +10,7 @@ export declare class GlyphInfoT {
     id: unknown;
     constructor(init?: GlyphInfoTInit);
     protected createPtr(init: GlyphInfoTInit): unknown;
+    static fromPtr(ptr: unknown): GlyphInfoT;
     /**
      * either a Unicode code point (before shaping) or a glyph index
      * (after shaping).

package/dist/generated/harfbuzz/glyph-info-t.js

@@ -1,5 +1,5 @@
 import { alloc, read, write } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * The #hb_glyph_info_t is the structure that holds information about the
  * glyphs and their relation to input text.
@@ -16,6 +16,11 @@ export class GlyphInfoT {
             write(ptr, { type: "int", size: 32, unsigned: true }, 8, init.cluster);
         return ptr;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(GlyphInfoT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /**
      * either a Unicode code point (before shaping) or a glyph index
      * (after shaping).

package/dist/generated/harfbuzz/glyph-position-t.d.ts

@@ -8,6 +8,7 @@ export declare class GlyphPositionT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): GlyphPositionT;
     /**
      * how much the line advances after drawing this glyph when setting
      * text in horizontal direction.

package/dist/generated/harfbuzz/glyph-position-t.js

@@ -1,5 +1,5 @@
 import { alloc, read } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * The #hb_glyph_position_t is the structure that holds the positions of the
  * glyph in both horizontal and vertical directions. All positions in
@@ -14,6 +14,11 @@ export class GlyphPositionT {
     createPtr(_init) {
         return alloc(40, "hb_glyph_position_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(GlyphPositionT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /**
      * how much the line advances after drawing this glyph when setting
      * text in horizontal direction.

package/dist/generated/harfbuzz/map-t.d.ts

@@ -4,4 +4,5 @@ export declare class MapT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): MapT;
 }

package/dist/generated/harfbuzz/map-t.js

@@ -1,4 +1,4 @@
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /** Data type for holding integer-to-integer hash maps. */
 export class MapT {
     static glibTypeName = "hb_map_t";
@@ -9,5 +9,10 @@ export class MapT {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(MapT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(MapT);

package/dist/generated/harfbuzz/ot-math-glyph-part-t.d.ts

@@ -9,6 +9,7 @@ export declare class OtMathGlyphPartT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): OtMathGlyphPartT;
     /** The glyph index of the variant part */
     get glyph(): number;
     /** The length of the connector on the starting side of the variant part */

package/dist/generated/harfbuzz/ot-math-glyph-part-t.js

@@ -1,5 +1,5 @@
 import { alloc, read } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Data type to hold information for a "part" component of a math-variant glyph.
  * Large variants for stretchable math glyphs (such as parentheses) can be constructed
@@ -14,6 +14,11 @@ export class OtMathGlyphPartT {
     createPtr(_init) {
         return alloc(40, "hb_ot_math_glyph_part_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(OtMathGlyphPartT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /** The glyph index of the variant part */
     get glyph() {
         return read(this.id, { type: "int", size: 64, unsigned: true }, 0);

package/dist/generated/harfbuzz/ot-math-glyph-variant-t.d.ts

@@ -4,6 +4,7 @@ export declare class OtMathGlyphVariantT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): OtMathGlyphVariantT;
     /** The glyph index of the variant */
     get glyph(): number;
     /** The advance width of the variant */

package/dist/generated/harfbuzz/ot-math-glyph-variant-t.js

@@ -1,5 +1,5 @@
 import { alloc, read } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /** Data type to hold math-variant information for a glyph. */
 export class OtMathGlyphVariantT {
     static glibTypeName = "hb_ot_math_glyph_variant_t";
@@ -10,6 +10,11 @@ export class OtMathGlyphVariantT {
     createPtr(_init) {
         return alloc(16, "hb_ot_math_glyph_variant_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(OtMathGlyphVariantT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /** The glyph index of the variant */
     get glyph() {
         return read(this.id, { type: "int", size: 64, unsigned: true }, 0);

package/dist/generated/harfbuzz/ot-var-axis-info-t.d.ts

@@ -18,6 +18,7 @@ export declare class OtVarAxisInfoT {
     id: unknown;
     constructor(init?: OtVarAxisInfoTInit);
     protected createPtr(init: OtVarAxisInfoTInit): unknown;
+    static fromPtr(ptr: unknown): OtVarAxisInfoT;
     /** Index of the axis in the variation-axis array */
     get axisIndex(): number;
     set axisIndex(value: number);

package/dist/generated/harfbuzz/ot-var-axis-info-t.js

@@ -1,5 +1,5 @@
 import { alloc, read, write } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Data type for holding variation-axis values.
  *
@@ -26,6 +26,11 @@ export class OtVarAxisInfoT {
             write(ptr, { type: "float", size: 32 }, 40, init.maxValue);
         return ptr;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(OtVarAxisInfoT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /** Index of the axis in the variation-axis array */
     get axisIndex() {
         return read(this.id, { type: "int", size: 32, unsigned: true }, 0);

package/dist/generated/harfbuzz/paint-funcs-t.d.ts

@@ -25,4 +25,5 @@ export declare class PaintFuncsT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): PaintFuncsT;
 }

package/dist/generated/harfbuzz/paint-funcs-t.js

@@ -1,4 +1,4 @@
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Glyph paint callbacks.
  *
@@ -30,5 +30,10 @@ export class PaintFuncsT {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(PaintFuncsT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(PaintFuncsT);

package/dist/generated/harfbuzz/segment-properties-t.d.ts

@@ -9,6 +9,7 @@ export declare class SegmentPropertiesT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): SegmentPropertiesT;
     /** the #hb_direction_t of the buffer, see hb_buffer_set_direction(). */
     get direction(): DirectionT;
     /** the #hb_script_t of the buffer, see hb_buffer_set_script(). */

package/dist/generated/harfbuzz/segment-properties-t.js

@@ -1,5 +1,5 @@
 import { alloc, read } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * The structure that holds various text properties of an #hb_buffer_t. Can be
  * set and retrieved using hb_buffer_set_segment_properties() and
@@ -14,6 +14,11 @@ export class SegmentPropertiesT {
     createPtr(_init) {
         return alloc(40, "hb_segment_properties_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(SegmentPropertiesT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
     /** the #hb_direction_t of the buffer, see hb_buffer_set_direction(). */
     get direction() {
         return read(this.id, { type: "int", size: 32, unsigned: false }, 0);

package/dist/generated/harfbuzz/set-t.d.ts

@@ -9,4 +9,5 @@ export declare class SetT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): SetT;
 }

package/dist/generated/harfbuzz/set-t.js

@@ -1,4 +1,4 @@
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Data type for holding a set of integers. #hb_set_t's are
  * used to gather and contain glyph IDs, Unicode code
@@ -14,5 +14,10 @@ export class SetT {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(SetT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(SetT);

package/dist/generated/harfbuzz/shape-plan-t.d.ts

@@ -14,4 +14,5 @@ export declare class ShapePlanT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): ShapePlanT;
 }

package/dist/generated/harfbuzz/shape-plan-t.js

@@ -1,4 +1,4 @@
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Data type for holding a shaping plan.
  *
@@ -19,5 +19,10 @@ export class ShapePlanT {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(ShapePlanT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(ShapePlanT);

package/dist/generated/harfbuzz/unicode-funcs-t.d.ts

@@ -13,4 +13,5 @@ export declare class UnicodeFuncsT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): UnicodeFuncsT;
 }

package/dist/generated/harfbuzz/unicode-funcs-t.js

@@ -1,4 +1,4 @@
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /**
  * Data type containing a set of virtual methods used for
  * accessing various Unicode character properties.
@@ -18,5 +18,10 @@ export class UnicodeFuncsT {
     createPtr(_init) {
         return null;
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(UnicodeFuncsT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(UnicodeFuncsT);

package/dist/generated/harfbuzz/user-data-key-t.d.ts

@@ -4,4 +4,5 @@ export declare class UserDataKeyT {
     id: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    static fromPtr(ptr: unknown): UserDataKeyT;
 }

package/dist/generated/harfbuzz/user-data-key-t.js

@@ -1,5 +1,5 @@
 import { alloc } from "@gtkx/native";
-import { registerType } from "@gtkx/ffi";
+import { registerType } from "../../registry.js";
 /** Data structure for holding user-data keys. */
 export class UserDataKeyT {
     static glibTypeName = "hb_user_data_key_t";
@@ -10,5 +10,10 @@ export class UserDataKeyT {
     createPtr(_init) {
         return alloc(1, "hb_user_data_key_t", "libharfbuzz-gobject.so.0,libharfbuzz.so.0");
     }
+    static fromPtr(ptr) {
+        const instance = Object.create(UserDataKeyT.prototype);
+        instance.id = ptr;
+        return instance;
+    }
 }
 registerType(UserDataKeyT);

package/dist/generated/javascriptcore/class.d.ts

@@ -1,4 +1,3 @@
-import { Value } from "./value.js";
 import * as GObject from "../gobject/index.js";
 /**
  * A JSSClass represents a custom JavaScript class registered by the user in a #JSCContext.
@@ -10,99 +9,6 @@ import * as GObject from "../gobject/index.js";
 export declare class Class extends GObject.GObject {
     static readonly glibTypeName: string;
     constructor();
-    /**
-     * Add a constructor to @jsc_class. If `name` is %NULL, the class name will be used. When <function>new</function>
-     * is used with the constructor or jsc_value_constructor_call() is called, `callback` is invoked receiving
-     * a #GPtrArray of #JSCValue<!-- -->s as arguments and `user_data` as the last parameter. When the constructor object
-     * is cleared in the #JSCClass context, `destroy_notify` is called with `user_data` as parameter.
-     *
-     * This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use
-     * jsc_context_set_value() to make the constructor available in the global object.
-     *
-     * Note that the value returned by `callback` is adopted by @jsc_class, and the #GDestroyNotify passed to
-     * jsc_context_register_class() is responsible for disposing of it.
-     * @param name - the constructor name or %NULL
-     * @param callback - a #GCallback to be called to create an instance of @jsc_class
-     * @param userData - user data to pass to @callback
-     * @param destroyNotify - destroy notifier for @user_data
-     * @param returnType - the #GType of the constructor return value
-     */
-    addConstructorVariadic(callback: (...args: unknown[]) => unknown, returnType: number, name?: string | null, userData?: number | null, destroyNotify?: () => void | null): Value;
-    /**
-     * Add a constructor to @jsc_class. If `name` is %NULL, the class name will be used. When <function>new</function>
-     * is used with the constructor or jsc_value_constructor_call() is called, `callback` is invoked receiving the
-     * parameters and `user_data` as the last parameter. When the constructor object is cleared in the #JSCClass context,
-     * `destroy_notify` is called with `user_data` as parameter.
-     *
-     * This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use
-     * jsc_context_set_value() to make the constructor available in the global object.
-     *
-     * Note that the value returned by `callback` is adopted by @jsc_class, and the #GDestroyNotify passed to
-     * jsc_context_register_class() is responsible for disposing of it.
-     * @param name - the constructor name or %NULL
-     * @param callback - a #GCallback to be called to create an instance of @jsc_class
-     * @param userData - user data to pass to @callback
-     * @param destroyNotify - destroy notifier for @user_data
-     * @param returnType - the #GType of the constructor return value
-     * @param nParameters - the number of parameters
-     * @param parameterTypes - a list of #GType<!-- -->s, one for each parameter, or %NULL
-     */
-    addConstructorv(callback: (...args: unknown[]) => unknown, returnType: number, nParameters: number, name?: string | null, userData?: number | null, destroyNotify?: () => void | null, parameterTypes?: number[] | null): Value;
-    /**
-     * Add method with `name` to @jsc_class. When the method is called by JavaScript or jsc_value_object_invoke_method(),
-     * `callback` is called receiving the class instance as first parameter, followed by a #GPtrArray of #JSCValue<!-- -->s
-     * with the method arguments and then `user_data` as last parameter. When the method is cleared in the #JSCClass context,
-     * `destroy_notify` is called with `user_data` as parameter.
-     *
-     * Note that the value returned by `callback` must be transfer full. In case of non-refcounted boxed types, you should use
-     * %G_TYPE_POINTER instead of the actual boxed #GType to ensure that the instance owned by #JSCClass is used.
-     * If you really want to return a new copy of the boxed type, use #JSC_TYPE_VALUE and return a #JSCValue created
-     * with jsc_value_new_object() that receives the copy as the instance parameter.
-     * @param name - the method name
-     * @param callback - a #GCallback to be called to invoke method `name` of @jsc_class
-     * @param userData - user data to pass to @callback
-     * @param destroyNotify - destroy notifier for @user_data
-     * @param returnType - the #GType of the method return value, or %G_TYPE_NONE if the method is void.
-     */
-    addMethodVariadic(name: string, callback: (...args: unknown[]) => unknown, returnType: number, userData?: number | null, destroyNotify?: () => void | null): void;
-    /**
-     * Add method with `name` to @jsc_class. When the method is called by JavaScript or jsc_value_object_invoke_method(),
-     * `callback` is called receiving the class instance as first parameter, followed by the method parameters and then
-     * `user_data` as last parameter. When the method is cleared in the #JSCClass context, `destroy_notify` is called with
-     * `user_data` as parameter.
-     *
-     * Note that the value returned by `callback` must be transfer full. In case of non-refcounted boxed types, you should use
-     * %G_TYPE_POINTER instead of the actual boxed #GType to ensure that the instance owned by #JSCClass is used.
-     * If you really want to return a new copy of the boxed type, use #JSC_TYPE_VALUE and return a #JSCValue created
-     * with jsc_value_new_object() that receives the copy as the instance parameter.
-     * @param name - the method name
-     * @param callback - a #GCallback to be called to invoke method `name` of @jsc_class
-     * @param userData - user data to pass to @callback
-     * @param destroyNotify - destroy notifier for @user_data
-     * @param returnType - the #GType of the method return value, or %G_TYPE_NONE if the method is void.
-     * @param nParameters - the number of parameter types to follow or 0 if the method doesn't receive parameters.
-     * @param parameterTypes - a list of #GType<!-- -->s, one for each parameter, or %NULL
-     */
-    addMethodv(name: string, callback: (...args: unknown[]) => unknown, returnType: number, nParameters: number, userData?: number | null, destroyNotify?: () => void | null, parameterTypes?: number[] | null): void;
-    /**
-     * Add a property with `name` to @jsc_class. When the property value needs to be getted, `getter` is called
-     * receiving the the class instance as first parameter and `user_data` as last parameter. When the property
-     * value needs to be set, `setter` is called receiving the the class instance as first parameter, followed
-     * by the value to be set and then `user_data` as the last parameter. When the property is cleared in the
-     * #JSCClass context, `destroy_notify` is called with `user_data` as parameter.
-     *
-     * Note that the value returned by `getter` must be transfer full. In case of non-refcounted boxed types, you should use
-     * %G_TYPE_POINTER instead of the actual boxed #GType to ensure that the instance owned by #JSCClass is used.
-     * If you really want to return a new copy of the boxed type, use #JSC_TYPE_VALUE and return a #JSCValue created
-     * with jsc_value_new_object() that receives the copy as the instance parameter.
-     * @param name - the property name
-     * @param propertyType - the #GType of the property value
-     * @param getter - a #GCallback to be called to get the property value
-     * @param setter - a #GCallback to be called to set the property value
-     * @param userData - user data to pass to `getter` and @setter
-     * @param destroyNotify - destroy notifier for @user_data
-     */
-    addProperty(name: string, propertyType: number, getter?: (...args: unknown[]) => unknown | null, setter?: (...args: unknown[]) => unknown | null, userData?: number | null, destroyNotify?: () => void | null): void;
     /**
      * Get the class name of @jsc_class
      */