@mlightcad/data-model 1.10.6 → 1.11.0

package/lib/database/AcDbDatabase.js

@@ -112,6 +112,9 @@ import { AcDbUnitsValue } from '../misc/AcDbUnitsValue';
 import { AcDbDictionary } from '../object/AcDbDictionary';
 import { AcDbMLeaderStyle } from '../object/AcDbMLeaderStyle';
 import { AcDbMlineStyle } from '../object/AcDbMlineStyle';
+import { AcDbXrecord } from '../object/AcDbXrecord';
+import { AcLyLayerFilterTree } from '../ly/AcLyLayerFilterTree';
+import { ACAD_LAYERFILTERS_NAME, ACLY_DICTIONARY_NAME, acdbLayerGroupsToResultBuffer, acdbSerializeLayerFilterTree } from '../ly/AcLyLayerFilterIO';
 import { AcDbBlockTable } from './AcDbBlockTable';
 import { AcDbBlockTableRecord } from './AcDbBlockTableRecord';
 import { AcDbOpenDatabaseError } from './AcDbOpenDatabaseError';
@@ -250,11 +253,14 @@ var AcDbDatabase = /** @class */ (function (_super) {
         _this._objects = {
             dictionary: new AcDbDictionary(_this),
             imageDefinition: new AcDbDictionary(_this),
+            layerFilter: new AcDbDictionary(_this),
+            layerIndex: new AcDbDictionary(_this),
             layout: new AcDbLayoutDictionary(_this),
             mleaderStyle: new AcDbDictionary(_this),
             mlineStyle: new AcDbDictionary(_this),
             xrecord: new AcDbDictionary(_this)
         };
+        _this._layerFilters = new AcLyLayerFilterTree();
         _this.transactionManager = new AcDbDatabaseTransactionManager(_this);
         _this.registerBootstrapHandles();
         return _this;
@@ -312,6 +318,45 @@ var AcDbDatabase = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcDbDatabase.prototype, "layerFilters", {
+        /**
+         * Gets the Layer Properties Manager filter tree for this database.
+         *
+         * @remarks
+         * Mirrors AutoCAD .NET `Database.LayerFilters` / ObjectARX `AcLy*` filters.
+         * This is the property/group filter **tree**, not the flat
+         * {@link objects.layerFilter} dictionary used by `AcDbLayerFilter` /
+         * `AcDbLayerIndex`.
+         *
+         * Like AutoCAD, treat this value as retrieved by value: mutate the tree,
+         * then assign it back via the setter if your workflow expects that pattern.
+         *
+         * @returns The current {@link AcLyLayerFilterTree}.
+         *
+         * @example
+         * ```typescript
+         * const tree = db.layerFilters;
+         * const filter = new AcLyLayerFilter();
+         * filter.name = 'Unlocked Layers';
+         * filter.setFilterExpression('LOCKED=="False"');
+         * tree.root.addNested(filter);
+         * db.layerFilters = tree;
+         * ```
+         */
+        get: function () {
+            return this._layerFilters;
+        },
+        /**
+         * Sets the Layer Properties Manager filter tree for this database.
+         *
+         * @param value - New filter tree.
+         */
+        set: function (value) {
+            this._layerFilters = value !== null && value !== void 0 ? value : new AcLyLayerFilterTree();
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Looks up a database-resident object by its object ID.
      *
@@ -407,6 +452,8 @@ var AcDbDatabase = /** @class */ (function (_super) {
         return [
             this.objects.dictionary,
             this.objects.imageDefinition,
+            this.objects.layerFilter,
+            this.objects.layerIndex,
             this.objects.layout,
             this.objects.mleaderStyle,
             this.objects.mlineStyle,
@@ -703,7 +750,16 @@ var AcDbDatabase = /** @class */ (function (_super) {
         this._handleRegistry.clear();
         this.registerObjectHandle(this);
         try {
-            for (var _c = __values(Object.values(this._tables)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            for (var _c = __values([
+                this._tables.blockTable,
+                this._tables.dimStyleTable,
+                this._tables.layerTable,
+                this._tables.linetypeTable,
+                this._tables.appIdTable,
+                this._tables.textStyleTable,
+                this._tables.viewTable,
+                this._tables.viewportTable
+            ]), _d = _c.next(); !_d.done; _d = _c.next()) {
                 var table = _d.value;
                 this.registerObjectHandle(table);
             }
@@ -716,7 +772,16 @@ var AcDbDatabase = /** @class */ (function (_super) {
             finally { if (e_3) throw e_3.error; }
         }
         try {
-            for (var _e = __values(Object.values(this._objects)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            for (var _e = __values([
+                this._objects.dictionary,
+                this._objects.imageDefinition,
+                this._objects.layerFilter,
+                this._objects.layerIndex,
+                this._objects.layout,
+                this._objects.mleaderStyle,
+                this._objects.mlineStyle,
+                this._objects.xrecord
+            ]), _f = _e.next(); !_f.done; _f = _e.next()) {
                 var dictionary = _f.value;
                 this.registerObjectHandle(dictionary);
             }
@@ -1877,6 +1942,10 @@ var AcDbDatabase = /** @class */ (function (_super) {
         if (version === void 0) { version = this.version.name; }
         if (_saveThumbnailImage === void 0) { _saveThumbnailImage = false; }
         this.ensureDatabaseDefaults();
+        if (this._layerFilters.root.getNestedFilters().length > 0 &&
+            !this.tables.layerTable.extensionDictionary) {
+            this.tables.layerTable.extensionDictionary = this.generateHandle();
+        }
         var outVersion = version instanceof AcDbDwgVersion ? version : new AcDbDwgVersion(version);
         var filer = new AcDbDxfFiler({
             database: this,
@@ -2413,7 +2482,7 @@ var AcDbDatabase = /** @class */ (function (_super) {
      * @param filer - DXF output writer.
      */
     AcDbDatabase.prototype.writeDxfObjectsSection = function (filer) {
-        var e_15, _a, e_16, _b, e_17, _c, e_18, _d, e_19, _e;
+        var e_15, _a, e_16, _b, e_17, _c, e_18, _d, e_19, _e, e_20, _f, e_21, _g;
         filer.startSection('OBJECTS');
         var rootDict = this.objects.dictionary;
         rootDict.ownerId = '0';
@@ -2472,8 +2541,8 @@ var AcDbDatabase = /** @class */ (function (_super) {
             writeDictionary(this.objects.xrecord);
         }
         try {
-            for (var _f = __values(this.objects.layout.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var _h = __read(_g.value, 2), _ = _h[0], layout = _h[1];
+            for (var _h = __values(this.objects.layout.entries()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var _k = __read(_j.value, 2), _ = _k[0], layout = _k[1];
                 filer.writeStart('LAYOUT');
                 layout.dxfOut(filer);
             }
@@ -2481,13 +2550,13 @@ var AcDbDatabase = /** @class */ (function (_super) {
         catch (e_15_1) { e_15 = { error: e_15_1 }; }
         finally {
             try {
-                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
             }
             finally { if (e_15) throw e_15.error; }
         }
         try {
-            for (var _j = __values(this.objects.imageDefinition.entries()), _k = _j.next(); !_k.done; _k = _j.next()) {
-                var _l = __read(_k.value, 2), _ = _l[0], imageDef = _l[1];
+            for (var _l = __values(this.objects.imageDefinition.entries()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var _o = __read(_m.value, 2), _ = _o[0], imageDef = _o[1];
                 filer.writeStart('IMAGEDEF');
                 imageDef.dxfOut(filer);
             }
@@ -2495,54 +2564,259 @@ var AcDbDatabase = /** @class */ (function (_super) {
         catch (e_16_1) { e_16 = { error: e_16_1 }; }
         finally {
             try {
-                if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+                if (_m && !_m.done && (_b = _l.return)) _b.call(_l);
             }
             finally { if (e_16) throw e_16.error; }
         }
         try {
-            for (var _m = __values(this.objects.mleaderStyle.entries()), _o = _m.next(); !_o.done; _o = _m.next()) {
-                var _p = __read(_o.value, 2), _ = _p[0], mleaderStyle = _p[1];
-                filer.writeStart('MLEADERSTYLE');
-                mleaderStyle.dxfOut(filer);
+            for (var _p = __values(this.objects.layerFilter.entries()), _q = _p.next(); !_q.done; _q = _p.next()) {
+                var _r = __read(_q.value, 2), _ = _r[0], layerFilter = _r[1];
+                filer.writeStart('LAYER_FILTER');
+                layerFilter.dxfOut(filer);
             }
         }
         catch (e_17_1) { e_17 = { error: e_17_1 }; }
         finally {
             try {
-                if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
+                if (_q && !_q.done && (_c = _p.return)) _c.call(_p);
             }
             finally { if (e_17) throw e_17.error; }
         }
         try {
-            for (var _q = __values(this.objects.mlineStyle.entries()), _r = _q.next(); !_r.done; _r = _q.next()) {
-                var _s = __read(_r.value, 2), _ = _s[0], mlineStyle = _s[1];
-                filer.writeStart('MLINESTYLE');
-                mlineStyle.dxfOut(filer);
+            for (var _s = __values(this.objects.layerIndex.entries()), _t = _s.next(); !_t.done; _t = _s.next()) {
+                var _u = __read(_t.value, 2), _ = _u[0], layerIndex = _u[1];
+                filer.writeStart('LAYER_INDEX');
+                layerIndex.dxfOut(filer);
             }
         }
         catch (e_18_1) { e_18 = { error: e_18_1 }; }
         finally {
             try {
-                if (_r && !_r.done && (_d = _q.return)) _d.call(_q);
+                if (_t && !_t.done && (_d = _s.return)) _d.call(_s);
             }
             finally { if (e_18) throw e_18.error; }
         }
         try {
-            for (var _t = __values(this.objects.xrecord.entries()), _u = _t.next(); !_u.done; _u = _t.next()) {
-                var _v = __read(_u.value, 2), _ = _v[0], xrecord = _v[1];
-                filer.writeStart('XRECORD');
-                xrecord.dxfOut(filer);
+            for (var _v = __values(this.objects.mleaderStyle.entries()), _w = _v.next(); !_w.done; _w = _v.next()) {
+                var _x = __read(_w.value, 2), _ = _x[0], mleaderStyle = _x[1];
+                filer.writeStart('MLEADERSTYLE');
+                mleaderStyle.dxfOut(filer);
             }
         }
         catch (e_19_1) { e_19 = { error: e_19_1 }; }
         finally {
             try {
-                if (_u && !_u.done && (_e = _t.return)) _e.call(_t);
+                if (_w && !_w.done && (_e = _v.return)) _e.call(_v);
             }
             finally { if (e_19) throw e_19.error; }
         }
+        try {
+            for (var _y = __values(this.objects.mlineStyle.entries()), _z = _y.next(); !_z.done; _z = _y.next()) {
+                var _0 = __read(_z.value, 2), _ = _0[0], mlineStyle = _0[1];
+                filer.writeStart('MLINESTYLE');
+                mlineStyle.dxfOut(filer);
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (_z && !_z.done && (_f = _y.return)) _f.call(_y);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+        try {
+            for (var _1 = __values(this.objects.xrecord.entries()), _2 = _1.next(); !_2.done; _2 = _1.next()) {
+                var _3 = __read(_2.value, 2), _ = _3[0], xrecord = _3[1];
+                filer.writeStart('XRECORD');
+                xrecord.dxfOut(filer);
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (_2 && !_2.done && (_g = _1.return)) _g.call(_1);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+        this.writeAcLyLayerFilterObjects(filer);
         filer.endSection();
     };
+    /**
+     * Writes Layer Manager filter tree objects (`ACAD_LAYERFILTERS` /
+     * `ACLYDICTIONARY` + XRecords) into the OBJECTS section and attaches an
+     * extension dictionary to the Layer Table.
+     *
+     * @param filer - DXF output writer.
+     */
+    AcDbDatabase.prototype.writeAcLyLayerFilterObjects = function (filer) {
+        var e_22, _a, e_23, _b, e_24, _c, e_25, _d, e_26, _e;
+        var _this = this;
+        var _f;
+        var serialized = acdbSerializeLayerFilterTree(this._layerFilters);
+        if (serialized.nodes.length === 0) {
+            return;
+        }
+        var dicts = [];
+        var xrecs = [];
+        var layerTable = this.tables.layerTable;
+        var layerExtHandle = (_f = layerTable.extensionDictionary) !== null && _f !== void 0 ? _f : this.generateHandle();
+        layerTable.extensionDictionary = layerExtHandle;
+        var aclyHandle = this.generateHandle();
+        var acadHandle = this.generateHandle();
+        var rootAclyEntries = [];
+        var rootAcadEntries = [];
+        var emit = function (node, parentAclyHandle, addToLegacy) {
+            var e_27, _a;
+            var xHandle = _this.generateHandle();
+            var extensionDictionaryId;
+            if (node.children.length > 0) {
+                var extHandle = _this.generateHandle();
+                var childAclyHandle = _this.generateHandle();
+                var childEntries = [];
+                try {
+                    for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var child = _c.value;
+                        childEntries.push({
+                            name: child.key,
+                            id: emit(child, childAclyHandle, false)
+                        });
+                    }
+                }
+                catch (e_27_1) { e_27 = { error: e_27_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_27) throw e_27.error; }
+                }
+                dicts.push({
+                    handle: extHandle,
+                    ownerId: xHandle,
+                    entries: [{ name: ACLY_DICTIONARY_NAME, id: childAclyHandle }]
+                });
+                dicts.push({
+                    handle: childAclyHandle,
+                    ownerId: extHandle,
+                    entries: childEntries
+                });
+                extensionDictionaryId = extHandle;
+            }
+            xrecs.push({
+                handle: xHandle,
+                ownerId: parentAclyHandle,
+                extensionDictionaryId: extensionDictionaryId,
+                data: node.data
+            });
+            if (addToLegacy) {
+                rootAcadEntries.push({ name: node.key, id: xHandle });
+            }
+            return xHandle;
+        };
+        try {
+            for (var _g = __values(serialized.nodes), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var node = _h.value;
+                rootAclyEntries.push({
+                    name: node.key,
+                    id: emit(node, aclyHandle, true)
+                });
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        var layerExtEntries = new Map();
+        var existingLayerExt = this.getObjectById(layerExtHandle);
+        if (existingLayerExt instanceof AcDbDictionary) {
+            try {
+                for (var _j = __values(existingLayerExt.entries()), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var _l = __read(_k.value, 2), key = _l[0], value = _l[1];
+                    layerExtEntries.set(key, value.objectId);
+                }
+            }
+            catch (e_23_1) { e_23 = { error: e_23_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+                }
+                finally { if (e_23) throw e_23.error; }
+            }
+        }
+        layerExtEntries.set(ACLY_DICTIONARY_NAME, aclyHandle);
+        layerExtEntries.set(ACAD_LAYERFILTERS_NAME, acadHandle);
+        dicts.unshift({
+            handle: layerExtHandle,
+            ownerId: layerTable.objectId,
+            entries: Array.from(layerExtEntries, function (_a) {
+                var _b = __read(_a, 2), name = _b[0], id = _b[1];
+                return ({ name: name, id: id });
+            })
+        }, {
+            handle: aclyHandle,
+            ownerId: layerExtHandle,
+            entries: rootAclyEntries
+        }, {
+            handle: acadHandle,
+            ownerId: layerExtHandle,
+            entries: rootAcadEntries
+        });
+        try {
+            for (var dicts_1 = __values(dicts), dicts_1_1 = dicts_1.next(); !dicts_1_1.done; dicts_1_1 = dicts_1.next()) {
+                var dict = dicts_1_1.value;
+                filer.writeStart('DICTIONARY');
+                filer.writeHandle(5, dict.handle);
+                filer.writeObjectId(330, dict.ownerId);
+                filer.writeSubclassMarker('AcDbDictionary');
+                filer.writeInt16(280, 1);
+                filer.writeInt16(281, 1);
+                try {
+                    for (var _m = (e_25 = void 0, __values(dict.entries)), _o = _m.next(); !_o.done; _o = _m.next()) {
+                        var entry = _o.value;
+                        filer.writeString(3, entry.name);
+                        filer.writeObjectId(350, entry.id);
+                    }
+                }
+                catch (e_25_1) { e_25 = { error: e_25_1 }; }
+                finally {
+                    try {
+                        if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+                    }
+                    finally { if (e_25) throw e_25.error; }
+                }
+            }
+        }
+        catch (e_24_1) { e_24 = { error: e_24_1 }; }
+        finally {
+            try {
+                if (dicts_1_1 && !dicts_1_1.done && (_c = dicts_1.return)) _c.call(dicts_1);
+            }
+            finally { if (e_24) throw e_24.error; }
+        }
+        try {
+            for (var xrecs_1 = __values(xrecs), xrecs_1_1 = xrecs_1.next(); !xrecs_1_1.done; xrecs_1_1 = xrecs_1.next()) {
+                var item = xrecs_1_1.value;
+                var xrecord = new AcDbXrecord();
+                xrecord.objectId = item.handle;
+                xrecord.ownerId = item.ownerId;
+                if (item.extensionDictionaryId) {
+                    xrecord.extensionDictionary = item.extensionDictionaryId;
+                }
+                xrecord.data = acdbLayerGroupsToResultBuffer(item.data);
+                filer.writeStart('XRECORD');
+                xrecord.dxfOut(filer);
+            }
+        }
+        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+        finally {
+            try {
+                if (xrecs_1_1 && !xrecs_1_1.done && (_e = xrecs_1.return)) _e.call(xrecs_1);
+            }
+            finally { if (e_26) throw e_26.error; }
+        }
+    };
     /**
      * Writes a single TABLE and its records into the TABLES section.
      *
@@ -2553,7 +2827,7 @@ var AcDbDatabase = /** @class */ (function (_super) {
      * @param recordType - DXF record type name for each table record.
      */
     AcDbDatabase.prototype.writeDxfTable = function (filer, tableName, table, records, recordType) {
-        var e_20, _a;
+        var e_28, _a;
         var items = __spreadArray([], __read(records), false);
         filer.startTable(tableName);
         table.dxfOut(filer);
@@ -2569,12 +2843,12 @@ var AcDbDatabase = /** @class */ (function (_super) {
                 record.dxfOut(filer);
             }
         }
-        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        catch (e_28_1) { e_28 = { error: e_28_1 }; }
         finally {
             try {
                 if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
             }
-            finally { if (e_20) throw e_20.error; }
+            finally { if (e_28) throw e_28.error; }
         }
         filer.endTable();
     };
@@ -2616,9 +2890,12 @@ var AcDbDatabase = /** @class */ (function (_super) {
         this._tables.viewportTable.removeAll();
         this._objects.layout.removeAll();
         this._objects.imageDefinition.removeAll();
+        this._objects.layerFilter.removeAll();
+        this._objects.layerIndex.removeAll();
         this._objects.mleaderStyle.removeAll();
         this._objects.mlineStyle.removeAll();
         this._objects.xrecord.removeAll();
+        this._layerFilters = new AcLyLayerFilterTree();
         this._currentSpace = undefined;
         this._extents.makeEmpty();
         this.registerBootstrapHandles();