@silkweaver/build 1.2.0 → 1.3.1

package/dist/build.js

@@ -410,6 +410,14 @@ async function _load_sprite(name: string, meta_url: string, img_base: string): P
             spr.mask_right  = (meta.mask_x || 0) + meta.mask_w
             spr.mask_bottom = (meta.mask_y || 0) + meta.mask_h
         }
+        // Scale mode (how the sprite fills a scaled area) + 9-slice border insets (sprite editor).
+        if (meta.scale_mode === 'tile' || meta.scale_mode === 'nineslice' || meta.scale_mode === 'stretch') {
+            spr.scale_mode = meta.scale_mode
+        }
+        spr.slice_left   = meta.slice_left   || 0
+        spr.slice_top    = meta.slice_top    || 0
+        spr.slice_right  = meta.slice_right  || 0
+        spr.slice_bottom = meta.slice_bottom || 0
 
         // Load all frames specified in meta.json
         const frames = meta.frames || []

package/dist/object_format.d.ts

@@ -10,7 +10,9 @@
  * Pure Node (typescript only) — unit-testable and reusable outside the IPC layer.
  */
 /** Known static-metadata field names an object class may declare. */
-export type meta_field = 'sprite' | 'solid' | 'visible' | 'persistent' | 'depth' | 'parent';
+export type meta_field = 'sprite' | 'solid' | 'visible' | 'persistent' | 'depth' | 'parent' | 'physics' | 'physics_shape' | 'physics_density' | 'physics_restitution' | 'physics_friction' | 'physics_sensor';
+/** Canonical order of the `static` metadata fields (keeps them tidy + consistent across files). */
+export declare const META_ORDER: string[];
 /** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
 export declare const EVENT_ORDER: string[];
 export interface object_model {
@@ -26,6 +28,7 @@ export interface object_model {
         value: string;
     }[];
     events: string[];
+    statics: Record<string, string>;
 }
 /** Extracts the object model from a class-file source. */
 export declare function parse_object(src: string): object_model;
@@ -68,9 +71,15 @@ export declare function get_event_body(src: string, method: string): string | nu
  */
 export declare function set_event_body(src: string, method: string, body: string): string;
 /**
- * Normalizes a class-per-object file for display in the full code view: variables hoisted above all
- * events, canonical event order, then consistent indentation. Unchanged if there's no class.
+ * Normalizes a class-per-object file for the full code view: metadata → variables → events
+ * (execution order), a `;` on every field, then consistent indentation. The IDE only applies this
+ * when the user's "auto-organize objects" setting is on. Unchanged if there's no class.
  */
 export declare function normalize_object(src: string): string;
-/** Generates a minimal class-file source for a new object. Imports are auto-managed (none needed). */
-export declare function scaffold_object(class_name: string): string;
+/**
+ * Generates a class-file source for a new object. `kind` picks a starting template:
+ *   - 'normal'  → an empty object with an on_create stub;
+ *   - 'physics' → a ready-to-run dynamic matter.js body (physics metadata + a body-sizing mask).
+ * Imports are auto-managed (none needed).
+ */
+export declare function scaffold_object(class_name: string, kind?: 'normal' | 'physics'): string;

package/dist/object_format.js

@@ -44,7 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENT_ORDER = void 0;
+exports.EVENT_ORDER = exports.META_ORDER = void 0;
 exports.parse_object = parse_object;
 exports.this_members = this_members;
 exports.set_static = set_static;
@@ -58,6 +58,24 @@ exports.set_event_body = set_event_body;
 exports.normalize_object = normalize_object;
 exports.scaffold_object = scaffold_object;
 const ts = __importStar(require("typescript"));
+/** Canonical order of the `static` metadata fields (keeps them tidy + consistent across files). */
+exports.META_ORDER = [
+    'sprite', 'parent', 'solid', 'visible', 'persistent', 'depth',
+    'physics', 'physics_shape', 'physics_density', 'physics_restitution', 'physics_friction', 'physics_sensor',
+];
+/**
+ * Explicit type annotations for static fields whose base-class type is narrower than what TypeScript
+ * would infer from the literal initializer. Without this, `static physics_shape = 'box'` widens to
+ * `string`, which doesn't satisfy the base's `'box' | 'circle'` and the subclass fails to compile.
+ */
+const META_TYPES = {
+    physics_shape: `'box' | 'circle'`,
+};
+/** Renders a `static <name>[: <type>] = <expr>;` declaration, adding an annotation where one is needed. */
+function _static_decl(name, expr) {
+    const ann = META_TYPES[name];
+    return `static ${name}${ann ? `: ${ann}` : ''} = ${expr};`;
+}
 /** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
 exports.EVENT_ORDER = [
     'on_create', 'on_destroy',
@@ -94,7 +112,7 @@ function parse_object(src) {
         class_name: cls?.name?.text ?? '',
         sprite: null, parent: null,
         solid: false, visible: true, persistent: false, depth: 0,
-        variables: [], events: [],
+        variables: [], events: [], statics: {},
     };
     if (!cls)
         return model;
@@ -111,6 +129,7 @@ function parse_object(src) {
                 continue;
             const init = m.initializer ? m.initializer.getText(sf) : '';
             if (_is_static(m)) {
+                model.statics[n] = init; // generic: every static field, by name
                 switch (n) {
                     case 'sprite':
                         model.sprite = _string_literal(m.initializer);
@@ -220,14 +239,32 @@ function set_static(src, name, expr) {
     if (!cls)
         return src;
     const existing = _find_member(cls, m => ts.isPropertyDeclaration(m) && _is_static(m) && _name_of(m) === name);
-    if (existing?.initializer) {
-        return _apply(src, { start: existing.initializer.getStart(sf), end: existing.initializer.getEnd(), text: expr });
-    }
     if (existing) {
-        // declared without initializer — replace the whole member
-        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `static ${name} = ${expr}` });
+        // For annotated fields (e.g. physics_shape) replace the whole member so the type annotation is
+        // always present/correct — updating just the initializer could leave it un-annotated (→ widens
+        // to string and fails to compile). For plain fields, the cheaper initializer-only edit is fine.
+        if (META_TYPES[name])
+            return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: _static_decl(name, expr) });
+        if (existing.initializer)
+            return _apply(src, { start: existing.initializer.getStart(sf), end: existing.initializer.getEnd(), text: expr });
+        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: _static_decl(name, expr) });
+    }
+    // New static: metadata lives at the TOP, ordered by META_ORDER. Insert before the first static
+    // that sorts after it; else before the first non-static member (so statics stay grouped up top).
+    const stub = `    ${_static_decl(name, expr)}\n`;
+    const order = exports.META_ORDER.indexOf(name);
+    if (order >= 0) {
+        const after = cls.members.find(m => {
+            const n = _name_of(m);
+            return ts.isPropertyDeclaration(m) && _is_static(m) && n != null && exports.META_ORDER.indexOf(n) > order;
+        });
+        if (after)
+            return _insert_before(src, after.getStart(sf), stub);
     }
-    return _insert_member(src, `    static ${name} = ${expr}\n`);
+    const first_non_static = cls.members.find(m => !(ts.isPropertyDeclaration(m) && _is_static(m)));
+    if (first_non_static)
+        return _insert_before(src, first_non_static.getStart(sf), stub);
+    return _insert_member(src, stub);
 }
 /** Removes a static metadata field if present (e.g. clearing the sprite). */
 function remove_static(src, name) {
@@ -244,15 +281,19 @@ function set_field(src, name, expr) {
         return _apply(src, { start: existing.initializer.getStart(sf), end: existing.initializer.getEnd(), text: expr });
     }
     if (existing) {
-        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `${name} = ${expr}` });
+        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `${name} = ${expr};` });
     }
-    // New variable: keep all instance variables grouped at the TOP of the class, in add-order, so
-    // every event below can reference them — and a later variable's initializer can safely read an
-    // earlier one. Insert after the last existing variable; if none, before the first member.
-    const stub = `    ${name} = ${expr}\n`;
-    const vars = cls.members.filter(m => ts.isPropertyDeclaration(m) && !_is_static(m));
+    // New variable: variables sit between the static metadata and the events, in add-order (so a later
+    // one can read an earlier one, and every event below can reference them). Insert after the last
+    // variable; else after the last static; else before the first member.
+    const stub = `    ${name} = ${expr};\n`;
+    const props = cls.members.filter(m => ts.isPropertyDeclaration(m));
+    const vars = props.filter(m => !_is_static(m));
+    const statics = props.filter(m => _is_static(m));
     if (vars.length)
         return _insert_after(src, vars[vars.length - 1].getEnd(), stub);
+    if (statics.length)
+        return _insert_after(src, statics[statics.length - 1].getEnd(), stub);
     if (cls.members.length)
         return _insert_before(src, cls.members[0].getStart(sf), stub);
     return _insert_member(src, stub);
@@ -463,12 +504,12 @@ function _reindent(code, unit = '    ') {
 }
 /**
  * Reorders all class members into canonical groups, preserving each member's attached comments:
- *   1. instance variables — in their existing relative order (field-init order can matter; one
+ *   1. `static` metadata (sprite/parent/solid/…) — at the TOP, in META_ORDER (non-meta statics after);
+ *   2. instance variables — in their existing relative order (field-init order can matter; one
  *      field's initializer may read another), so they're grouped but never shuffled among themselves;
- *   2. `on_*` event methods — in canonical EVENT_ORDER;
- *   3. everything else (statics, helper methods) — in place.
- * Variables-before-events is the whole point: every event can reference every variable. A no-op if
- * the order is already canonical.
+ *   3. `on_*` event methods — in canonical EVENT_ORDER;
+ *   4. everything else (helper methods) — in place, at the bottom.
+ * Metadata → variables → events (execution order) is the canonical shape. A no-op if already canonical.
  */
 function _reorder_members(src) {
     const sf = _source(src);
@@ -480,11 +521,19 @@ function _reorder_members(src) {
         const n = _name_of(m);
         return n && ts.isMethodDeclaration(m) ? exports.EVENT_ORDER.indexOf(n) : -1;
     };
+    const is_static_prop = (m) => ts.isPropertyDeclaration(m) && _is_static(m);
     const is_var = (m) => ts.isPropertyDeclaration(m) && !_is_static(m);
+    // Statics: META_ORDER fields first (sprite, parent, …); any other static keeps its relative place.
+    const static_key = (m) => {
+        const n = _name_of(m);
+        const i = n ? exports.META_ORDER.indexOf(n) : -1;
+        return i >= 0 ? i : exports.META_ORDER.length + members.indexOf(m);
+    };
+    const statics = members.filter(is_static_prop).sort((a, b) => static_key(a) - static_key(b));
     const vars = members.filter(is_var);
     const events = members.filter(m => event_idx(m) >= 0).sort((a, b) => event_idx(a) - event_idx(b));
-    const others = members.filter(m => !is_var(m) && event_idx(m) < 0);
-    const ordered = [...vars, ...events, ...others];
+    const rest = members.filter(m => !is_static_prop(m) && !is_var(m) && event_idx(m) < 0);
+    const ordered = [...statics, ...vars, ...events, ...rest];
     if (ordered.every((m, i) => m === members[i]))
         return src; // already canonical
     // Rebuild the class body from each member's full text (getFullStart → getEnd includes the leading
@@ -495,18 +544,56 @@ function _reorder_members(src) {
     const suffix = src.slice(members[members.length - 1].getEnd());
     return prefix + ordered.map(chunk).join('') + suffix;
 }
+/** Ensures every field declaration (static + instance) ends with a `;`. Methods are left as-is. */
+function _ensure_field_semicolons(src) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return src;
+    const ends = [];
+    for (const m of cls.members) {
+        if (!ts.isPropertyDeclaration(m))
+            continue;
+        const end = m.getEnd();
+        if (src[end - 1] !== ';')
+            ends.push(end);
+    }
+    let out = src;
+    for (const pos of ends.sort((a, b) => b - a))
+        out = out.slice(0, pos) + ';' + out.slice(pos);
+    return out;
+}
 /**
- * Normalizes a class-per-object file for display in the full code view: variables hoisted above all
- * events, canonical event order, then consistent indentation. Unchanged if there's no class.
+ * Normalizes a class-per-object file for the full code view: metadata → variables → events
+ * (execution order), a `;` on every field, then consistent indentation. The IDE only applies this
+ * when the user's "auto-organize objects" setting is on. Unchanged if there's no class.
  */
 function normalize_object(src) {
-    return _reindent(_reorder_members(src));
+    return _reindent(_ensure_field_semicolons(_reorder_members(src)));
 }
 // =========================================================================
 // Scaffolding
 // =========================================================================
-/** Generates a minimal class-file source for a new object. Imports are auto-managed (none needed). */
-function scaffold_object(class_name) {
+/**
+ * Generates a class-file source for a new object. `kind` picks a starting template:
+ *   - 'normal'  → an empty object with an on_create stub;
+ *   - 'physics' → a ready-to-run dynamic matter.js body (physics metadata + a body-sizing mask).
+ * Imports are auto-managed (none needed).
+ */
+function scaffold_object(class_name, kind = 'normal') {
+    if (kind === 'physics') {
+        return `export class ${class_name} extends gm_object {
+    static physics = true;
+    static physics_shape: 'box' | 'circle' = 'box';
+    static physics_density = 0.5;
+    static physics_restitution = 0.1;
+    static physics_friction = 0.2;
+    on_create(): void {
+        this.mask_set_size(32, 32);
+    }
+}
+`;
+    }
     return `export class ${class_name} extends gm_object {
     on_create(): void {
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@silkweaver/build",
-    "version": "1.2.0",
+    "version": "1.3.1",
     "description": "Silkweaver toolchain — compiles a project folder into a runnable game (HTML5 / desktop executable). Usable from a CLI or the IDE.",
     "type": "commonjs",
     "license": "GPL-3.0",