@mlightcad/data-model 1.15.23 → 1.15.25

package/lib/object/AcDbGroup.js

@@ -49,47 +49,148 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+import { AcCmColor } from '@mlightcad/common';
 import { AcDbObject } from '../base/AcDbObject.js';
+import { AcDbEntity } from '../entity/AcDbEntity.js';
+import { AcDbObjectIterator } from '../misc/AcDbObjectIterator.js';
 /**
- * Nongraphical GROUP object (DXF GROUP).
+ * Nongraphical GROUP object (DXF GROUP / ObjectARX `AcDbGroup`).
  *
- * Minimal fields: name, unnamed/selectable flags, and soft-pointers to
- * member entity handles.
+ * A group is an ordered, named persistent selection set of database entities.
+ * It does not own its members. The group **name** is the key in the
+ * `ACAD_GROUP` dictionary; DXF group code 300 stores the **description**.
+ *
+ * @remarks
+ * ObjectARX requires the group to be added to the group dictionary (so it has
+ * an object id) before members are appended.
  */
 var AcDbGroup = /** @class */ (function (_super) {
     __extends(AcDbGroup, _super);
-    function AcDbGroup() {
-        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+    /**
+     * Creates a new group.
+     *
+     * @param description - Optional description (ObjectARX ctor first arg).
+     * @param selectable - Whether the group is selectable as a unit (default `true`).
+     */
+    function AcDbGroup(description, selectable) {
+        if (description === void 0) { description = ''; }
+        if (selectable === void 0) { selectable = true; }
+        var _this = _super.call(this) || this;
+        /** Dictionary key name of this group (`ACAD_GROUP` entry). */
         _this._name = '';
-        _this._unnamed = false;
+        /** Group description (DXF group 300). */
+        _this._description = '';
+        /** True when this is an anonymous (`*A…`) group. */
+        _this._anonymous = false;
+        /** Whether the group can be selected as a unit. */
         _this._selectable = true;
+        /** Soft-pointer member entity ids, in group order. */
         _this._entityIds = [];
+        _this.description = description;
+        _this.selectable = selectable;
         return _this;
     }
     Object.defineProperty(AcDbGroup.prototype, "name", {
+        /**
+         * Gets the dictionary key name of this group (`ACAD_GROUP` entry).
+         *
+         * @returns The group name.
+         */
         get: function () {
             return this._name;
         },
+        /**
+         * Sets the dictionary key name of this group.
+         *
+         * Prefer {@link setName} when the group is already stored in
+         * `database.objects.group`, so the dictionary key stays in sync.
+         *
+         * @param value - The new group name.
+         */
         set: function (value) {
             this._name = value;
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcDbGroup.prototype, "description", {
+        /**
+         * Gets the group description (DXF group 300).
+         *
+         * @returns The description string.
+         */
+        get: function () {
+            return this._description;
+        },
+        /**
+         * Sets the group description (DXF group 300).
+         *
+         * @param value - The new description.
+         */
+        set: function (value) {
+            this._description = String(value !== null && value !== void 0 ? value : '');
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcDbGroup.prototype, "unnamed", {
+        /**
+         * Gets whether this is an anonymous (`*A…`) group.
+         *
+         * @returns `true` when the group is anonymous.
+         *
+         * @deprecated Prefer {@link isAnonymous} / {@link setAnonymous}.
+         */
+        get: function () {
+            return this._anonymous;
+        },
+        /**
+         * Sets whether this is an anonymous group.
+         *
+         * @param value - `true` to mark the group anonymous.
+         *
+         * @deprecated Prefer {@link isAnonymous} / {@link setAnonymous}.
+         */
+        set: function (value) {
+            this._anonymous = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbGroup.prototype, "anonymous", {
+        /**
+         * Gets whether this is an anonymous group.
+         *
+         * @returns `true` when the group is anonymous.
+         */
         get: function () {
-            return this._unnamed;
+            return this._anonymous;
         },
+        /**
+         * Sets whether this is an anonymous group.
+         *
+         * @param value - `true` to mark the group anonymous.
+         */
         set: function (value) {
-            this._unnamed = value;
+            this._anonymous = value;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(AcDbGroup.prototype, "selectable", {
+        /**
+         * Gets whether the group can be selected as a unit.
+         *
+         * @returns `true` when the group is selectable.
+         */
         get: function () {
             return this._selectable;
         },
+        /**
+         * Sets whether the group can be selected as a unit.
+         *
+         * @param value - `true` to allow selecting the group as a unit.
+         */
         set: function (value) {
             this._selectable = value;
         },
@@ -97,42 +198,542 @@ var AcDbGroup = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbGroup.prototype, "entityIds", {
+        /**
+         * Gets soft-pointer member entity ids, in group order.
+         *
+         * @returns A readonly view of member object ids.
+         */
         get: function () {
             return this._entityIds;
         },
+        /**
+         * Replaces the entire member id list.
+         *
+         * @param value - New ordered list of member object ids.
+         */
         set: function (value) {
             this._entityIds = __spreadArray([], __read(value), false);
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Appends one member id to the group.
+     *
+     * @param id - Object id of the entity to append.
+     *
+     * @deprecated Prefer {@link append}.
+     */
     AcDbGroup.prototype.addEntityId = function (id) {
-        this._entityIds.push(id);
+        this.append(id);
     };
-    AcDbGroup.prototype.dxfOutFields = function (filer) {
+    /**
+     * Returns whether this group is anonymous.
+     *
+     * Mirrors ObjectARX `AcDbGroup::isAnonymous`.
+     *
+     * @returns `true` when the group is anonymous.
+     */
+    AcDbGroup.prototype.isAnonymous = function () {
+        return this._anonymous;
+    };
+    /**
+     * Marks this group as anonymous.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setAnonymous`.
+     */
+    AcDbGroup.prototype.setAnonymous = function () {
+        this._anonymous = true;
+    };
+    /**
+     * Returns whether the group is not accessible.
+     *
+     * Mirrors ObjectARX `AcDbGroup::isNotAccessible`. This port always returns
+     * `false` (inaccessible/proxy groups are not modeled).
+     *
+     * @returns Always `false`.
+     */
+    AcDbGroup.prototype.isNotAccessible = function () {
+        return false;
+    };
+    /**
+     * Sets the group name and, when database-bound, renames its `ACAD_GROUP`
+     * dictionary entry to match.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setName`.
+     *
+     * @param name - The new group name.
+     */
+    AcDbGroup.prototype.setName = function (name) {
         var e_1, _a;
+        var _b;
+        var next = String(name !== null && name !== void 0 ? name : '');
+        var dict = (_b = this.database) === null || _b === void 0 ? void 0 : _b.objects.group;
+        if (!dict) {
+            this._name = next;
+            return;
+        }
+        // Prefer the in-memory name when it still matches the dict entry; otherwise
+        // scan for this object (e.g. setAt before name was assigned).
+        var currentKey;
+        if (this._name && dict.getAt(this._name) === this) {
+            currentKey = this._name;
+        }
+        else {
+            try {
+                for (var _c = __values(dict.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), key = _e[0], existing = _e[1];
+                    if (existing === this) {
+                        currentKey = key;
+                        break;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        if (currentKey === next) {
+            this._name = next;
+            return;
+        }
+        // Do not overwrite another group; leave `_name` unchanged on collision.
+        var conflict = next ? dict.getAt(next) : undefined;
+        if (conflict && conflict !== this)
+            return;
+        if (currentKey != null && currentKey !== next) {
+            dict.remove(currentKey);
+            if (next)
+                dict.setAt(next, this);
+        }
+        this._name = next;
+    };
+    /**
+     * Returns the number of member entities in the group.
+     *
+     * Mirrors ObjectARX `AcDbGroup::numEntities`.
+     *
+     * @returns Member count.
+     */
+    AcDbGroup.prototype.numEntities = function () {
+        return this._entityIds.length;
+    };
+    /**
+     * Copies all member object ids into `out` (when provided) and returns the
+     * member count.
+     *
+     * Mirrors ObjectARX `AcDbGroup::allEntityIds`.
+     *
+     * @param out - Optional array cleared and filled with member ids.
+     * @returns The number of member ids.
+     */
+    AcDbGroup.prototype.allEntityIds = function (out) {
+        if (out) {
+            out.length = 0;
+            out.push.apply(out, __spreadArray([], __read(this._entityIds), false));
+        }
+        return this._entityIds.length;
+    };
+    /**
+     * Returns whether the group contains the given entity or object id.
+     *
+     * Mirrors ObjectARX `AcDbGroup::has`.
+     *
+     * @param entityOrId - An {@link AcDbEntity} or an object id string.
+     * @returns `true` when the id is a member of this group.
+     */
+    AcDbGroup.prototype.has = function (entityOrId) {
+        var _a;
+        var id = typeof entityOrId === 'string' ? entityOrId : ((_a = entityOrId.objectId) !== null && _a !== void 0 ? _a : '');
+        if (!id)
+            return false;
+        return this._entityIds.includes(id);
+    };
+    /**
+     * Returns the zero-based index of a member id, or `-1` when not found.
+     *
+     * Mirrors ObjectARX `AcDbGroup::getIndex`.
+     *
+     * @param id - Member object id to look up.
+     * @returns Index in the group, or `-1`.
+     */
+    AcDbGroup.prototype.getIndex = function (id) {
+        return this._entityIds.indexOf(id);
+    };
+    /**
+     * Creates an iterator over member object ids (in group order).
+     *
+     * Uses the shared {@link AcDbObjectIterator} pattern of this codebase
+     * (rather than ObjectARX `AcDbGroupIterator`).
+     *
+     * @returns An iterator yielding member {@link AcDbObjectId} values.
+     *
+     * @example
+     * ```typescript
+     * for (const id of group.newIterator()) {
+     *   const entity = db.getObjectById(id)
+     * }
+     * ```
+     */
+    AcDbGroup.prototype.newIterator = function () {
+        return new AcDbObjectIterator(this._entityIds);
+    };
+    /**
+     * Appends one or more member ids to the end of the group.
+     *
+     * Duplicate ids already in the group are ignored. Mirrors ObjectARX
+     * `AcDbGroup::append`.
+     *
+     * @param idOrIds - A single object id or an array of object ids.
+     */
+    AcDbGroup.prototype.append = function (idOrIds) {
+        var e_2, _a;
+        var ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+        try {
+            for (var ids_1 = __values(ids), ids_1_1 = ids_1.next(); !ids_1_1.done; ids_1_1 = ids_1.next()) {
+                var id = ids_1_1.value;
+                if (!id || this._entityIds.includes(id))
+                    continue;
+                this._entityIds.push(id);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    /**
+     * Prepends one or more member ids to the start of the group.
+     *
+     * Duplicate ids already in the group are ignored. Mirrors ObjectARX
+     * `AcDbGroup::prepend`.
+     *
+     * @param idOrIds - A single object id or an array of object ids.
+     */
+    AcDbGroup.prototype.prepend = function (idOrIds) {
+        var ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+        for (var i = ids.length - 1; i >= 0; i--) {
+            var id = ids[i];
+            if (!id || this._entityIds.includes(id))
+                continue;
+            this._entityIds.unshift(id);
+        }
+    };
+    /**
+     * Inserts one or more member ids at the given index.
+     *
+     * Duplicate ids already in the group are ignored. Mirrors ObjectARX
+     * `AcDbGroup::insertAt`.
+     *
+     * @param index - Zero-based insertion index (clamped to `[0, length]`).
+     * @param idOrIds - A single object id or an array of object ids.
+     */
+    AcDbGroup.prototype.insertAt = function (index, idOrIds) {
+        var _a;
+        var _this = this;
+        var ids = (Array.isArray(idOrIds) ? idOrIds : [idOrIds]).filter(function (id) { return !!id && !_this._entityIds.includes(id); });
+        if (ids.length === 0)
+            return;
+        var at = Math.max(0, Math.min(this._entityIds.length, Math.trunc(index)));
+        (_a = this._entityIds).splice.apply(_a, __spreadArray([at, 0], __read(ids), false));
+    };
+    /**
+     * Removes one or more members by object id.
+     *
+     * Mirrors ObjectARX `AcDbGroup::remove`.
+     *
+     * @param idOrIds - A single object id or an array of object ids to remove.
+     */
+    AcDbGroup.prototype.remove = function (idOrIds) {
+        var toRemove = new Set((Array.isArray(idOrIds) ? idOrIds : [idOrIds]).filter(Boolean));
+        if (toRemove.size === 0)
+            return;
+        this._entityIds = this._entityIds.filter(function (id) { return !toRemove.has(id); });
+    };
+    /**
+     * Removes a member at `index`, or removes the given ids starting from that
+     * index when `ids` is provided.
+     *
+     * Mirrors ObjectARX `AcDbGroup::removeAt`.
+     *
+     * @param index - Zero-based index of the first member to consider.
+     * @param ids - Optional subset of ids to remove from `index` onward.
+     */
+    AcDbGroup.prototype.removeAt = function (index, ids) {
+        var at = Math.trunc(index);
+        if (at < 0 || at >= this._entityIds.length)
+            return;
+        if (ids && ids.length > 0) {
+            var toRemove_1 = new Set(ids.filter(Boolean));
+            this._entityIds = this._entityIds.filter(function (id, i) {
+                if (i < at)
+                    return true;
+                return !toRemove_1.has(id);
+            });
+            return;
+        }
+        this._entityIds.splice(at, 1);
+    };
+    /**
+     * Replaces one member id with another.
+     *
+     * If `newId` is already in the group, `oldId` is simply removed. Mirrors
+     * ObjectARX `AcDbGroup::replace`.
+     *
+     * @param oldId - Existing member object id.
+     * @param newId - Replacement object id.
+     */
+    AcDbGroup.prototype.replace = function (oldId, newId) {
+        if (!oldId || !newId || oldId === newId)
+            return;
+        var index = this._entityIds.indexOf(oldId);
+        if (index < 0)
+            return;
+        if (this._entityIds.includes(newId)) {
+            this._entityIds.splice(index, 1);
+            return;
+        }
+        this._entityIds[index] = newId;
+    };
+    /**
+     * Moves `num` members starting at `fromIndex` so they begin at `toIndex`.
+     *
+     * Mirrors ObjectARX `AcDbGroup::transfer`.
+     *
+     * @param fromIndex - Start index of the block to move.
+     * @param toIndex - Destination index for the block.
+     * @param num - Number of members to move.
+     */
+    AcDbGroup.prototype.transfer = function (fromIndex, toIndex, num) {
+        var _a;
+        var from = Math.trunc(fromIndex);
+        var to = Math.trunc(toIndex);
+        var count = Math.trunc(num);
+        if (count <= 0 || from < 0 || from >= this._entityIds.length)
+            return;
+        var slice = this._entityIds.splice(from, count);
+        var insertAt = to;
+        if (to > from)
+            insertAt = Math.max(0, to - slice.length);
+        insertAt = Math.max(0, Math.min(this._entityIds.length, insertAt));
+        (_a = this._entityIds).splice.apply(_a, __spreadArray([insertAt, 0], __read(slice), false));
+    };
+    /**
+     * Reverses the order of members in the group.
+     *
+     * Mirrors ObjectARX `AcDbGroup::reverse`.
+     */
+    AcDbGroup.prototype.reverse = function () {
+        this._entityIds.reverse();
+    };
+    /**
+     * Removes all members from the group.
+     *
+     * Mirrors ObjectARX `AcDbGroup::clear`.
+     */
+    AcDbGroup.prototype.clear = function () {
+        this._entityIds = [];
+    };
+    /**
+     * Sets the color of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setColor`.
+     *
+     * @param color - Color to apply (cloned onto each entity).
+     */
+    AcDbGroup.prototype.setColor = function (color) {
+        var e_3, _a;
+        try {
+            for (var _b = __values(this.memberEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                entity.color = color.clone();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    /**
+     * Sets the ACI color of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setColorIndex`.
+     *
+     * @param index - AutoCAD Color Index (`0`–`256`).
+     */
+    AcDbGroup.prototype.setColorIndex = function (index) {
+        var color = new AcCmColor();
+        color.colorIndex = index;
+        this.setColor(color);
+    };
+    /**
+     * Sets the layer of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setLayer`. When `layerOrId` is an object id
+     * of a layer table record, the record's name is used.
+     *
+     * @param layerOrId - Layer name or layer-table-record object id.
+     */
+    AcDbGroup.prototype.setLayer = function (layerOrId) {
+        var e_4, _a;
+        var layerName = this.resolveLayerName(layerOrId);
+        if (!layerName)
+            return;
+        try {
+            for (var _b = __values(this.memberEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                entity.layer = layerName;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /**
+     * Sets the linetype of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setLinetype`. When `linetypeOrId` is an
+     * object id of a linetype table record, the record's name is used.
+     *
+     * @param linetypeOrId - Linetype name or linetype-table-record object id.
+     */
+    AcDbGroup.prototype.setLinetype = function (linetypeOrId) {
+        var e_5, _a;
+        var name = this.resolveLinetypeName(linetypeOrId);
+        if (!name)
+            return;
+        try {
+            for (var _b = __values(this.memberEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                entity.lineType = name;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    /**
+     * Sets the linetype scale of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setLinetypeScale`.
+     *
+     * @param scale - Linetype scale factor.
+     */
+    AcDbGroup.prototype.setLinetypeScale = function (scale) {
+        var e_6, _a;
+        try {
+            for (var _b = __values(this.memberEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                entity.linetypeScale = scale;
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    /**
+     * Sets the material of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setMaterial`. Currently a no-op because
+     * entities keep material as a raw DXF extra without a typed setter.
+     *
+     * @param _materialOrId - Material name or material object id.
+     */
+    AcDbGroup.prototype.setMaterial = function (_materialOrId) {
+        // Entities keep material as a raw DXF extra today; no typed setter yet.
+    };
+    /**
+     * Sets the visibility of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setVisibility`.
+     *
+     * @param visible - `true` to show members; `false` to hide them.
+     */
+    AcDbGroup.prototype.setVisibility = function (visible) {
+        var e_7, _a;
+        try {
+            for (var _b = __values(this.memberEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                entity.visibility = visible;
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    /**
+     * Sets the highlight state of every resolvable member entity.
+     *
+     * Mirrors ObjectARX `AcDbGroup::setHighlight`. Currently a no-op because
+     * this model has no per-entity highlight persistence.
+     *
+     * @param _highlight - Desired highlight state.
+     */
+    AcDbGroup.prototype.setHighlight = function (_highlight) {
+        // No per-entity highlight persistence in this model.
+    };
+    /**
+     * Writes DXF subclass fields for this group.
+     *
+     * @param filer - DXF output writer.
+     * @returns This instance for chaining.
+     */
+    AcDbGroup.prototype.dxfOutFields = function (filer) {
+        var e_8, _a;
         _super.prototype.dxfOutFields.call(this, filer);
         filer.writeSubclassMarker('AcDbGroup');
-        if (this.name) {
-            filer.writeString(300, this.name);
+        if (this._description) {
+            filer.writeString(300, this._description);
         }
-        filer.writeInt16(70, this.unnamed ? 1 : 0);
-        filer.writeInt16(71, this.selectable ? 1 : 0);
+        filer.writeInt16(70, this._anonymous ? 1 : 0);
+        filer.writeInt16(71, this._selectable ? 1 : 0);
         try {
             for (var _b = __values(this._entityIds), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var id = _c.value;
                 filer.writeObjectId(340, id);
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_8) throw e_8.error; }
         }
         return this;
     };
+    /**
+     * Reads DXF subclass fields for this group.
+     *
+     * @param filer - DXF input reader positioned at this object.
+     * @returns This instance for chaining.
+     */
     AcDbGroup.prototype.dxfInFields = function (filer) {
         _super.prototype.dxfInFields.call(this, filer);
         filer.atSubclassData('AcDbGroup');
@@ -148,13 +749,13 @@ var AcDbGroup = /** @class */ (function (_super) {
             }
             switch (code) {
                 case 300:
-                    this._name = String(item.value);
+                    this.description = item.value;
                     break;
                 case 70:
-                    this._unnamed = Number(item.value) !== 0;
+                    this.anonymous = Number(item.value) !== 0;
                     break;
                 case 71:
-                    this._selectable = Number(item.value) !== 0;
+                    this.selectable = Number(item.value) !== 0;
                     break;
                 case 340:
                     this._entityIds.push(String(item.value));
@@ -165,6 +766,72 @@ var AcDbGroup = /** @class */ (function (_super) {
         }
         return this;
     };
+    /**
+     * Resolves member ids to {@link AcDbEntity} instances via the owning
+     * database. Non-entity or missing ids are skipped.
+     *
+     * @returns Entities currently resolvable from {@link entityIds}.
+     */
+    AcDbGroup.prototype.memberEntities = function () {
+        var e_9, _a;
+        var db = this.database;
+        if (!db)
+            return [];
+        var result = [];
+        try {
+            for (var _b = __values(this._entityIds), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var id = _c.value;
+                var obj = db.getObjectById(id);
+                if (obj instanceof AcDbEntity)
+                    result.push(obj);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return result;
+    };
+    /**
+     * Resolves a layer name from a name string or layer-table-record object id.
+     *
+     * @param layerOrId - Layer name or object id.
+     * @returns Layer name to apply to member entities.
+     */
+    AcDbGroup.prototype.resolveLayerName = function (layerOrId) {
+        var db = this.database;
+        if (!db)
+            return String(layerOrId !== null && layerOrId !== void 0 ? layerOrId : '');
+        var asId = db.getObjectById(layerOrId);
+        if (asId &&
+            'name' in asId &&
+            typeof asId.name === 'string') {
+            return asId.name;
+        }
+        return String(layerOrId !== null && layerOrId !== void 0 ? layerOrId : '');
+    };
+    /**
+     * Resolves a linetype name from a name string or linetype-table-record
+     * object id.
+     *
+     * @param linetypeOrId - Linetype name or object id.
+     * @returns Linetype name to apply to member entities.
+     */
+    AcDbGroup.prototype.resolveLinetypeName = function (linetypeOrId) {
+        var db = this.database;
+        if (!db)
+            return String(linetypeOrId !== null && linetypeOrId !== void 0 ? linetypeOrId : '');
+        var asId = db.getObjectById(linetypeOrId);
+        if (asId &&
+            'name' in asId &&
+            typeof asId.name === 'string') {
+            return asId.name;
+        }
+        return String(linetypeOrId !== null && linetypeOrId !== void 0 ? linetypeOrId : '');
+    };
     return AcDbGroup;
 }(AcDbObject));
 export { AcDbGroup };