@mlightcad/cad-simple-viewer 1.5.6 → 1.5.7

package/lib/service/AcApLayerService.js

@@ -0,0 +1,1240 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcCmColor, AcCmColorMethod, AcDbLayerTableRecord } from '@mlightcad/data-model';
+import { getLayerIsoState, isSameLayerIsoState } from './AcApLayerIsoState';
+import { acapRunServiceEdit, LAYER_EDIT_LABEL } from './AcApServiceEdit';
+import { LAYER_FROZEN_FLAG, LAYER_LOCKED_FLAG } from './types';
+/**
+ * Centralizes layer table mutations for commands and UI consumers.
+ *
+ * Wraps on/off, freeze/thaw, lock/unlock, color, isolation (`LAYISO`/`LAYUNISO`),
+ * deletion (`LAYDEL`), and related operations with consistent undo handling.
+ * Document-scoped session state (`LAYERP`, `LAYUNISO` snapshots) lives on
+ * {@link AcApDocument}.
+ */
+var AcApLayerService = /** @class */ (function () {
+    /**
+     * Creates a layer service bound to a database.
+     *
+     * @param db - Database whose layer table will be mutated.
+     */
+    function AcApLayerService(db) {
+        this.db = db;
+    }
+    /** Opens an existing layer table record for write.
+     *
+     * @param db - Database containing the layer table.
+     * @param layerOrName - Layer record or name to open.
+     * @returns Opened layer record, or `undefined` when not found.
+     */
+    AcApLayerService.openLayerForWrite = function (db, layerOrName) {
+        var layer = typeof layerOrName === 'string'
+            ? db.tables.layerTable.getAt(layerOrName)
+            : layerOrName;
+        if (!layer)
+            return undefined;
+        return db.openObjectForWrite(layer.objectId);
+    };
+    /** Sets or clears the frozen bit on a layer record.
+     *
+     * @param layer - Layer record to modify.
+     * @param frozen - Desired frozen state.
+     */
+    AcApLayerService.setLayerFrozenState = function (layer, frozen) {
+        var _a;
+        var flags = (_a = layer.standardFlags) !== null && _a !== void 0 ? _a : 0;
+        layer.standardFlags = frozen
+            ? flags | LAYER_FROZEN_FLAG
+            : flags & ~LAYER_FROZEN_FLAG;
+    };
+    /** Sets or clears the locked bit on a layer record.
+     *
+     * @param layer - Layer record to modify.
+     * @param locked - Desired locked state.
+     */
+    AcApLayerService.setLayerLockedState = function (layer, locked) {
+        var _a;
+        var flags = (_a = layer.standardFlags) !== null && _a !== void 0 ? _a : 0;
+        layer.standardFlags = locked
+            ? flags | LAYER_LOCKED_FLAG
+            : flags & ~LAYER_LOCKED_FLAG;
+    };
+    /** Returns whether a layer is locked according to its standard flags.
+     *
+     * @param layer - Layer record to inspect.
+     * @returns `true` when the locked bit is set.
+     */
+    AcApLayerService.isLayerLocked = function (layer) {
+        var _a;
+        return (((_a = layer.standardFlags) !== null && _a !== void 0 ? _a : 0) & LAYER_LOCKED_FLAG) !== 0;
+    };
+    /**
+     * Applies a captured `LAYERP` snapshot to a database.
+     *
+     * @param db - Database whose layer table should be updated.
+     * @param snapshot - Snapshot previously captured on the owning document.
+     * @returns `true` when the snapshot's current layer still exists.
+     */
+    AcApLayerService.applyLayerPreviousSnapshot = function (db, snapshot) {
+        snapshot.states.forEach(function (state) {
+            var layer = AcApLayerService.openLayerForWrite(db, state.name);
+            if (!layer)
+                return;
+            layer.isOff = !state.isOn;
+            AcApLayerService.setLayerFrozenState(layer, state.isFrozen);
+            AcApLayerService.setLayerLockedState(layer, state.isLocked);
+        });
+        var currentLayer = AcApLayerService.openLayerForWrite(db, snapshot.clayer);
+        if (!currentLayer)
+            return false;
+        currentLayer.isOff = false;
+        AcApLayerService.setLayerFrozenState(currentLayer, false);
+        db.clayer = currentLayer.name;
+        return true;
+    };
+    /**
+     * Parses layer name input supporting `*` and comma-separated names.
+     *
+     * @param input - Raw user input (e.g. `A,B` or `*`).
+     * @returns Deduplicated list of layer names.
+     */
+    AcApLayerService.prototype.parseLayerNameInput = function (input) {
+        var allNames = __spreadArray([], __read(this.db.tables.layerTable.newIterator()), false).map(function (layer) { return layer.name; });
+        var raw = input.trim();
+        if (!raw)
+            return [];
+        if (raw === '*')
+            return __spreadArray([], __read(allNames), false);
+        var names = raw
+            .split(',')
+            .map(function (v) { return v.trim(); })
+            .filter(Boolean);
+        return __spreadArray([], __read(new Set(names)), false);
+    };
+    /**
+     * Resolves layer records by name.
+     *
+     * @param names - Layer names to look up.
+     * @returns Resolved records and names that were not found.
+     */
+    AcApLayerService.prototype.resolveLayers = function (names) {
+        var table = this.db.tables.layerTable;
+        var layers = [];
+        var missing = [];
+        names.forEach(function (name) {
+            var layer = table.getAt(name);
+            if (layer)
+                layers.push(layer);
+            else
+                missing.push(name);
+        });
+        return { layers: layers, missing: missing };
+    };
+    /**
+     * Returns summary rows for all layers.
+     *
+     * @returns Display-oriented summary for each layer in the table.
+     */
+    AcApLayerService.prototype.getLayerSummaries = function () {
+        var _this = this;
+        return __spreadArray([], __read(this.db.tables.layerTable.newIterator()), false).map(function (layer) { return ({
+            name: layer.name,
+            current: _this.db.clayer === layer.name ? '*' : '',
+            on: layer.isOff ? 'No' : 'Yes',
+            frozen: layer.isFrozen ? 'Yes' : 'No',
+            locked: AcApLayerService.isLayerLocked(layer) ? 'Yes' : 'No',
+            color: layer.color.toString()
+        }); });
+    };
+    /**
+     * Creates missing layers.
+     *
+     * @param names - Layer names to create.
+     * @returns Count of created layers and names that already existed.
+     */
+    AcApLayerService.prototype.createLayers = function (names) {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var table = _this.db.tables.layerTable;
+            var created = 0;
+            var existed = [];
+            names.forEach(function (name) {
+                if (table.has(name)) {
+                    existed.push(name);
+                    return;
+                }
+                table.add(new AcDbLayerTableRecord({
+                    name: name,
+                    isOff: false,
+                    isPlottable: true,
+                    color: new AcCmColor(AcCmColorMethod.ByACI, 7),
+                    linetype: 'Continuous'
+                }));
+                created++;
+            });
+            return { created: created, existed: existed };
+        });
+    };
+    /**
+     * Sets current layer (`CLAYER`), ensuring it is on and thawed.
+     *
+     * @param name - Layer name to make current.
+     * @returns `true` when the layer exists and was set current.
+     */
+    AcApLayerService.prototype.setCurrentLayer = function (name) {
+        var _this = this;
+        var layer = this.db.tables.layerTable.getAt(name);
+        if (!layer)
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return false;
+            opened.isOff = false;
+            AcApLayerService.setLayerFrozenState(opened, false);
+            _this.db.clayer = opened.name;
+            return true;
+        });
+    };
+    /**
+     * Creates a layer if missing, then makes it current.
+     *
+     * @param name - Layer name to create or activate.
+     * @returns `true` when the layer is current after the operation.
+     */
+    AcApLayerService.prototype.makeLayer = function (name) {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var table = _this.db.tables.layerTable;
+            var layer = table.getAt(name);
+            if (!layer) {
+                layer = new AcDbLayerTableRecord({
+                    name: name,
+                    isOff: false,
+                    isPlottable: true,
+                    color: new AcCmColor(AcCmColorMethod.ByACI, 7),
+                    linetype: 'Continuous'
+                });
+                table.add(layer);
+            }
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return false;
+            opened.isOff = false;
+            AcApLayerService.setLayerFrozenState(opened, false);
+            _this.db.clayer = opened.name;
+            return true;
+        });
+    };
+    /**
+     * Turns a single layer on or off.
+     *
+     * When turning off the current layer, pass `{ switchCurrentLayer: true }`
+     * (as {@link AcApLayerStore} does) to move `CLAYER` first. CLI commands leave
+     * the default `false` and rely on batch helpers to skip the current layer.
+     *
+     * @param layerName - Target layer name.
+     * @param isOn - Desired visibility (`true` = on).
+     * @param options - Optional behavior when turning off the current layer.
+     * @returns `true` when the layer exists and was updated.
+     */
+    AcApLayerService.prototype.setLayerOn = function (layerName, isOn, options) {
+        var _this = this;
+        var _a;
+        if (options === void 0) { options = {}; }
+        if (!layerName || !this.db.tables.layerTable.getAt(layerName)) {
+            return false;
+        }
+        var switchCurrentLayer = (_a = options.switchCurrentLayer) !== null && _a !== void 0 ? _a : false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            if (!isOn &&
+                switchCurrentLayer &&
+                !_this.switchCurrentLayerIfNeeded(layerName)) {
+                return false;
+            }
+            var layer = AcApLayerService.openLayerForWrite(_this.db, layerName);
+            if (!layer)
+                return false;
+            layer.isOff = !isOn;
+            return true;
+        });
+    };
+    /**
+     * Freezes or thaws a single layer.
+     *
+     * UI callers should pass `{ switchCurrentLayer: true }` when freezing the
+     * current layer so drawing continues on a visible, thawed layer.
+     *
+     * @param layerName - Target layer name.
+     * @param frozen - Desired frozen state.
+     * @param options - Optional behavior when freezing the current layer.
+     * @returns `true` when the layer exists and was updated.
+     */
+    AcApLayerService.prototype.setLayerFrozen = function (layerName, frozen, options) {
+        var _this = this;
+        var _a;
+        if (options === void 0) { options = {}; }
+        if (!layerName || !this.db.tables.layerTable.getAt(layerName)) {
+            return false;
+        }
+        var switchCurrentLayer = (_a = options.switchCurrentLayer) !== null && _a !== void 0 ? _a : false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            if (frozen &&
+                switchCurrentLayer &&
+                !_this.switchCurrentLayerIfNeeded(layerName)) {
+                return false;
+            }
+            var layer = AcApLayerService.openLayerForWrite(_this.db, layerName);
+            if (!layer)
+                return false;
+            AcApLayerService.setLayerFrozenState(layer, frozen);
+            return true;
+        });
+    };
+    /**
+     * Locks or unlocks a single layer.
+     *
+     * @param layerName - Target layer name.
+     * @param locked - Desired locked state.
+     * @returns `true` when the layer exists and was updated.
+     */
+    AcApLayerService.prototype.setLayerLocked = function (layerName, locked) {
+        var _this = this;
+        if (!layerName || !this.db.tables.layerTable.getAt(layerName)) {
+            return false;
+        }
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var layer = AcApLayerService.openLayerForWrite(_this.db, layerName);
+            if (!layer)
+                return false;
+            AcApLayerService.setLayerLockedState(layer, locked);
+            return true;
+        });
+    };
+    /**
+     * Assigns line weight to a single layer.
+     *
+     * @param layerName - Target layer name.
+     * @param lineWeight - Line weight value to assign.
+     * @returns `true` when the layer exists and line weight was set.
+     */
+    AcApLayerService.prototype.setLayerLineWeight = function (layerName, lineWeight) {
+        var _this = this;
+        if (!this.db.tables.layerTable.getAt(layerName))
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var layer = AcApLayerService.openLayerForWrite(_this.db, layerName);
+            if (!layer)
+                return false;
+            layer.lineWeight = lineWeight;
+            return true;
+        });
+    };
+    /**
+     * Keeps one layer visible and turns all others off (UI quick-isolate).
+     *
+     * Does not capture a `LAYUNISO` snapshot; use {@link isolateLayers} for
+     * command semantics.
+     *
+     * @param layerName - Layer to keep visible.
+     * @returns `true` when the layer exists and isolation was applied.
+     */
+    AcApLayerService.prototype.isolateSingleLayer = function (layerName) {
+        var _this = this;
+        if (!this.db.tables.layerTable.getAt(layerName))
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_1, _a;
+            try {
+                for (var _b = __values(_this.db.tables.layerTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var layer = _c.value;
+                    var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                    if (!opened)
+                        continue;
+                    var keepVisible = opened.name === layerName;
+                    opened.isOff = !keepVisible;
+                    if (keepVisible) {
+                        AcApLayerService.setLayerFrozenState(opened, false);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            _this.db.clayer = layerName;
+            return true;
+        });
+    };
+    /**
+     * Batch toggles layer visibility.
+     *
+     * @param names - Layer names to update.
+     * @param off - `true` to turn layers off, `false` to turn them on.
+     * @param options - Optional skip rules for the current layer.
+     * @returns Names of current layers skipped when turning off.
+     */
+    AcApLayerService.prototype.setLayersVisibility = function (names, off, options) {
+        var _this = this;
+        var _a;
+        if (options === void 0) { options = {}; }
+        var skipCurrentLayer = (_a = options.skipCurrentLayer) !== null && _a !== void 0 ? _a : true;
+        var layers = this.resolveLayers(names).layers;
+        var skippedCurrent = [];
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            layers.forEach(function (layer) {
+                if (off && skipCurrentLayer && layer.name === _this.db.clayer) {
+                    skippedCurrent.push(layer.name);
+                    return;
+                }
+                var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                if (!opened)
+                    return;
+                opened.isOff = off;
+            });
+        });
+        return { skippedCurrent: skippedCurrent };
+    };
+    /**
+     * Turns on every layer in the table.
+     *
+     * @returns Number of layers changed from off to on.
+     */
+    AcApLayerService.prototype.setAllLayersOn = function () {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_2, _a;
+            var turnedOn = 0;
+            try {
+                for (var _b = __values(_this.db.tables.layerTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var layer = _c.value;
+                    if (!layer.isOff)
+                        continue;
+                    var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                    if (!opened)
+                        continue;
+                    opened.isOff = false;
+                    turnedOn++;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return turnedOn;
+        });
+    };
+    /**
+     * Turns off every layer except the current layer.
+     *
+     * @returns Number of layers turned off.
+     */
+    AcApLayerService.prototype.setAllLayersOffExceptCurrent = function () {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_3, _a;
+            var currentLayer = _this.db.clayer;
+            var changed = 0;
+            try {
+                for (var _b = __values(_this.db.tables.layerTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var layer = _c.value;
+                    if (layer.name === currentLayer || layer.isOff)
+                        continue;
+                    var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                    if (!opened)
+                        continue;
+                    opened.isOff = true;
+                    changed++;
+                }
+            }
+            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; }
+            }
+            return changed;
+        });
+    };
+    /**
+     * Batch toggles frozen state.
+     *
+     * @param names - Layer names to update.
+     * @param freeze - `true` to freeze, `false` to thaw.
+     * @param options - Optional skip rules for the current layer.
+     * @returns Names of current layers skipped when freezing.
+     */
+    AcApLayerService.prototype.setLayersFrozen = function (names, freeze, options) {
+        var _this = this;
+        var _a;
+        if (options === void 0) { options = {}; }
+        var skipCurrentLayer = (_a = options.skipCurrentLayer) !== null && _a !== void 0 ? _a : true;
+        var layers = this.resolveLayers(names).layers;
+        var skippedCurrent = [];
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            layers.forEach(function (layer) {
+                if (freeze && skipCurrentLayer && layer.name === _this.db.clayer) {
+                    skippedCurrent.push(layer.name);
+                    return;
+                }
+                var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                if (!opened)
+                    return;
+                AcApLayerService.setLayerFrozenState(opened, freeze);
+            });
+        });
+        return { skippedCurrent: skippedCurrent };
+    };
+    /**
+     * Thaws all frozen layers in the table.
+     *
+     * @returns Number of layers thawed.
+     */
+    AcApLayerService.prototype.thawAllLayers = function () {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_4, _a;
+            var thawed = 0;
+            try {
+                for (var _b = __values(_this.db.tables.layerTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var layer = _c.value;
+                    if (!layer.isFrozen)
+                        continue;
+                    var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                    if (!opened)
+                        continue;
+                    AcApLayerService.setLayerFrozenState(opened, false);
+                    thawed++;
+                }
+            }
+            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; }
+            }
+            return thawed;
+        });
+    };
+    /**
+     * Batch toggles lock state.
+     *
+     * @param names - Layer names to update.
+     * @param lock - `true` to lock, `false` to unlock.
+     */
+    AcApLayerService.prototype.setLayersLocked = function (names, lock) {
+        var _this = this;
+        var layers = this.resolveLayers(names).layers;
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            layers.forEach(function (layer) {
+                var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                if (!opened)
+                    return;
+                AcApLayerService.setLayerLockedState(opened, lock);
+            });
+        });
+    };
+    /**
+     * Parses color input for layer color assignment.
+     *
+     * Accepts ACI index (1–255) or color strings understood by {@link AcCmColor.fromString}.
+     *
+     * @param input - Raw color string from the user or UI.
+     * @returns Parsed color, or `undefined` when invalid.
+     */
+    AcApLayerService.prototype.parseColorInput = function (input) {
+        var value = input.trim();
+        if (!value)
+            return undefined;
+        if (/^\d+$/.test(value)) {
+            var index = Number(value);
+            if (index >= 1 && index <= 255) {
+                return new AcCmColor(AcCmColorMethod.ByACI, index);
+            }
+            return undefined;
+        }
+        var color = AcCmColor.fromString(value);
+        if (!color)
+            return undefined;
+        if (color.isByACI) {
+            var index = color.colorIndex;
+            if (index == null || index < 1 || index > 255) {
+                return undefined;
+            }
+        }
+        if (color.isByLayer || color.isByBlock)
+            return undefined;
+        return color;
+    };
+    /**
+     * Assigns color to a single layer.
+     *
+     * @param layerName - Target layer name.
+     * @param color - Color to assign.
+     * @returns `true` when the layer exists and color was set.
+     */
+    AcApLayerService.prototype.setLayerColor = function (layerName, color) {
+        var _this = this;
+        if (!this.db.tables.layerTable.getAt(layerName))
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var layer = AcApLayerService.openLayerForWrite(_this.db, layerName);
+            if (!layer)
+                return false;
+            layer.color = color.clone();
+            return true;
+        });
+    };
+    /**
+     * Assigns the same color to multiple layers.
+     *
+     * @param names - Layer names to update.
+     * @param color - Color to assign to each resolved layer.
+     */
+    AcApLayerService.prototype.setLayersColor = function (names, color) {
+        var _this = this;
+        var layers = this.resolveLayers(names).layers;
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            layers.forEach(function (layer) {
+                var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                if (!opened)
+                    return;
+                opened.color = color.clone();
+            });
+        });
+    };
+    /**
+     * Updates a layer description.
+     *
+     * @param name - Target layer name.
+     * @param description - New description text.
+     * @returns `true` when the layer exists and description was set.
+     */
+    AcApLayerService.prototype.setLayerDescription = function (name, description) {
+        var _this = this;
+        var layer = this.db.tables.layerTable.getAt(name);
+        if (!layer)
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return false;
+            opened.description = description;
+            return true;
+        });
+    };
+    /**
+     * Moves `CLAYER` away from a layer before turning it off or freezing it.
+     *
+     * @param targetLayerName - Layer that will be turned off or frozen.
+     * @returns `true` when `CLAYER` is no longer the target layer, or target was not current.
+     */
+    AcApLayerService.prototype.switchCurrentLayerIfNeeded = function (targetLayerName) {
+        var e_5, _a;
+        if (this.db.clayer !== targetLayerName)
+            return true;
+        var fallbackLayerName;
+        var preferredLayerName;
+        try {
+            for (var _b = __values(this.db.tables.layerTable.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var layer = _c.value;
+                if (layer.name === targetLayerName)
+                    continue;
+                fallbackLayerName !== null && fallbackLayerName !== void 0 ? fallbackLayerName : (fallbackLayerName = layer.name);
+                if (!layer.isOff && !layer.isFrozen) {
+                    preferredLayerName = layer.name;
+                    break;
+                }
+            }
+        }
+        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; }
+        }
+        var nextLayerName = preferredLayerName !== null && preferredLayerName !== void 0 ? preferredLayerName : fallbackLayerName;
+        if (!nextLayerName)
+            return false;
+        var nextCurrentLayer = AcApLayerService.openLayerForWrite(this.db, nextLayerName);
+        if (!nextCurrentLayer)
+            return false;
+        nextCurrentLayer.isOff = false;
+        AcApLayerService.setLayerFrozenState(nextCurrentLayer, false);
+        this.db.clayer = nextCurrentLayer.name;
+        return true;
+    };
+    /**
+     * Resolves the layer name of an entity.
+     *
+     * @param objectId - Entity object id.
+     * @returns Trimmed layer name, or `undefined` when the entity is missing.
+     */
+    AcApLayerService.prototype.getLayerNameFromEntity = function (objectId) {
+        var _a;
+        var entity = this.db.tables.blockTable.getEntityById(objectId);
+        return ((_a = entity === null || entity === void 0 ? void 0 : entity.layer) === null || _a === void 0 ? void 0 : _a.trim()) || undefined;
+    };
+    /**
+     * Collects distinct layer names from a set of entity ids.
+     *
+     * @param objectIds - Entity ids to inspect.
+     * @returns Resolved layer names and names missing from the layer table.
+     */
+    AcApLayerService.prototype.collectLayerNamesFromEntities = function (objectIds) {
+        var _this = this;
+        var names = new Set();
+        var missing = new Set();
+        objectIds.forEach(function (objectId) {
+            var layerName = _this.getLayerNameFromEntity(objectId);
+            if (!layerName)
+                return;
+            var layer = _this.db.tables.layerTable.getAt(layerName);
+            if (layer) {
+                names.add(layer.name);
+            }
+            else {
+                missing.add(layerName);
+            }
+        });
+        return { layerNames: __spreadArray([], __read(names), false), missingLayerNames: __spreadArray([], __read(missing), false) };
+    };
+    /**
+     * Freezes the layer of a picked entity (`LAYFRZ`).
+     *
+     * @param objectId - Selected entity id.
+     * @returns Outcome with previous frozen state for session undo, or a failure reason.
+     */
+    AcApLayerService.prototype.freezeLayerByEntity = function (objectId) {
+        var _this = this;
+        var layerName = this.getLayerNameFromEntity(objectId);
+        if (!layerName) {
+            return { ok: false, reason: 'invalid_selection' };
+        }
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return { ok: false, reason: 'layer_not_found', layerName: layerName };
+        }
+        if (layer.name === this.db.clayer) {
+            return { ok: false, reason: 'cannot_change_current', layerName: layerName };
+        }
+        if (layer.isFrozen) {
+            return { ok: false, reason: 'already_frozen', layerName: layerName };
+        }
+        var wasFrozen = layer.isFrozen;
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return;
+            AcApLayerService.setLayerFrozenState(opened, true);
+        });
+        return { ok: true, layerName: layerName, previousFrozen: wasFrozen };
+    };
+    /**
+     * Restores frozen state by layer name for `LAYFRZ` session undo.
+     *
+     * @param layerName - Target layer name.
+     * @param frozen - Frozen state to restore.
+     * @returns `true` when the layer exists and state was applied.
+     */
+    AcApLayerService.prototype.setLayerFrozenByName = function (layerName, frozen) {
+        var _this = this;
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer)
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return false;
+            AcApLayerService.setLayerFrozenState(opened, frozen);
+            return true;
+        });
+    };
+    /**
+     * Turns off the layer of a picked entity (`LAYOFF`).
+     *
+     * @param objectId - Selected entity id.
+     * @returns Outcome with previous off state for session undo, or a failure reason.
+     */
+    AcApLayerService.prototype.turnOffLayerByEntity = function (objectId) {
+        var _this = this;
+        var layerName = this.getLayerNameFromEntity(objectId);
+        if (!layerName) {
+            return { ok: false, reason: 'invalid_selection' };
+        }
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return { ok: false, reason: 'layer_not_found', layerName: layerName };
+        }
+        if (layer.name === this.db.clayer) {
+            return { ok: false, reason: 'cannot_change_current', layerName: layerName };
+        }
+        if (layer.isOff) {
+            return { ok: false, reason: 'already_off', layerName: layerName };
+        }
+        var wasOff = layer.isOff;
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return;
+            opened.isOff = true;
+        });
+        return { ok: true, layerName: layerName, previousOff: wasOff };
+    };
+    /**
+     * Restores off state by layer name for `LAYOFF` session undo.
+     *
+     * @param layerName - Target layer name.
+     * @param off - Off state to restore.
+     * @returns `true` when the layer exists and state was applied.
+     */
+    AcApLayerService.prototype.setLayerOffByName = function (layerName, off) {
+        var _this = this;
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer)
+            return false;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return false;
+            opened.isOff = off;
+            return true;
+        });
+    };
+    /**
+     * Locks the layer of a picked entity (`LAYLCK`).
+     *
+     * @param objectId - Selected entity id.
+     * @returns Success or failure outcome.
+     */
+    AcApLayerService.prototype.lockLayerByEntity = function (objectId) {
+        var _this = this;
+        var layerName = this.getLayerNameFromEntity(objectId);
+        if (!layerName) {
+            return { ok: false, reason: 'invalid_selection' };
+        }
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return { ok: false, reason: 'layer_not_found', layerName: layerName };
+        }
+        if (AcApLayerService.isLayerLocked(layer)) {
+            return { ok: false, reason: 'already_locked', layerName: layerName };
+        }
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return;
+            AcApLayerService.setLayerLockedState(opened, true);
+        });
+        return { ok: true, layerName: layerName };
+    };
+    /**
+     * Unlocks the layer of a picked entity (`LAYULK`).
+     *
+     * @param objectId - Selected entity id.
+     * @returns Success or failure outcome.
+     */
+    AcApLayerService.prototype.unlockLayerByEntity = function (objectId) {
+        var _this = this;
+        var layerName = this.getLayerNameFromEntity(objectId);
+        if (!layerName) {
+            return { ok: false, reason: 'invalid_selection' };
+        }
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return { ok: false, reason: 'layer_not_found', layerName: layerName };
+        }
+        if (!AcApLayerService.isLayerLocked(layer)) {
+            return { ok: false, reason: 'already_unlocked', layerName: layerName };
+        }
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+            if (!opened)
+                return;
+            AcApLayerService.setLayerLockedState(opened, false);
+        });
+        return { ok: true, layerName: layerName };
+    };
+    /**
+     * Isolates layers by name using `LAYISO` semantics.
+     *
+     * Target layers are turned on, thawed, and unlocked. Other layers are turned off
+     * or locked depending on `isolationMode`. `LockAndFade` locks only; the viewer
+     * does not render a fade effect.
+     *
+     * @param layerNames - Names of layers to keep visible.
+     * @param isolationMode - How non-isolated layers are hidden.
+     * @returns Isolation result with undo snapshot, or `undefined` when `layerNames` is empty.
+     */
+    AcApLayerService.prototype.isolateLayers = function (layerNames, isolationMode) {
+        var _this = this;
+        if (layerNames.length === 0)
+            return undefined;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_6, _a, e_7, _b, e_8, _c;
+            var table = _this.db.tables.layerTable;
+            var targetNames = new Set(layerNames);
+            var targetLayer = table.getAt(layerNames[0]);
+            var currentLayerBefore = _this.db.clayer;
+            var beforeStates = new Map();
+            try {
+                for (var _d = __values(table.newIterator()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var layer = _e.value;
+                    beforeStates.set(layer.name, getLayerIsoState(layer));
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            if (targetLayer) {
+                _this.db.clayer = targetLayer.name;
+            }
+            var affectedLayerNames = new Set();
+            try {
+                for (var _f = __values(table.newIterator()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var layer = _g.value;
+                    var opened = AcApLayerService.openLayerForWrite(_this.db, layer);
+                    if (!opened)
+                        continue;
+                    if (targetNames.has(opened.name)) {
+                        if (opened.isOff) {
+                            opened.isOff = false;
+                            affectedLayerNames.add(opened.name);
+                        }
+                        if (opened.isFrozen) {
+                            AcApLayerService.setLayerFrozenState(opened, false);
+                            affectedLayerNames.add(opened.name);
+                        }
+                        if (AcApLayerService.isLayerLocked(opened)) {
+                            AcApLayerService.setLayerLockedState(opened, false);
+                            affectedLayerNames.add(opened.name);
+                        }
+                        continue;
+                    }
+                    if (isolationMode === 'Off') {
+                        if (!opened.isOff) {
+                            opened.isOff = true;
+                            affectedLayerNames.add(opened.name);
+                        }
+                        continue;
+                    }
+                    if (!AcApLayerService.isLayerLocked(opened)) {
+                        AcApLayerService.setLayerLockedState(opened, true);
+                        affectedLayerNames.add(opened.name);
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            var snapshots = [];
+            try {
+                for (var _h = __values(table.newIterator()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var layer = _j.value;
+                    var before = beforeStates.get(layer.name);
+                    if (!before)
+                        continue;
+                    var isolated = getLayerIsoState(layer);
+                    if (!isSameLayerIsoState(before, isolated)) {
+                        snapshots.push({
+                            name: layer.name,
+                            before: before,
+                            isolated: isolated
+                        });
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            var isoSnapshot = {
+                currentLayerBefore: currentLayerBefore,
+                currentLayerAfter: _this.db.clayer,
+                layers: snapshots
+            };
+            return {
+                layerNames: layerNames,
+                affectedLayerCount: affectedLayerNames.size,
+                isoSnapshot: isoSnapshot
+            };
+        });
+    };
+    /**
+     * Restores a `LAYISO` snapshot.
+     *
+     * @param snapshot - Snapshot previously produced by {@link isolateLayers}.
+     * @returns Number of layers whose state was restored.
+     */
+    AcApLayerService.prototype.unisolateFromSnapshot = function (snapshot) {
+        var _this = this;
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var e_9, _a;
+            var table = _this.db.tables.layerTable;
+            var restoredLayers = 0;
+            try {
+                for (var _b = __values(snapshot.layers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var entry = _c.value;
+                    if (!table.getAt(entry.name))
+                        continue;
+                    if (_this.restoreLayerIfUnchanged(entry)) {
+                        restoredLayers++;
+                    }
+                }
+            }
+            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; }
+            }
+            if (_this.db.clayer === snapshot.currentLayerAfter &&
+                snapshot.currentLayerBefore !== snapshot.currentLayerAfter &&
+                table.getAt(snapshot.currentLayerBefore)) {
+                _this.db.clayer = snapshot.currentLayerBefore;
+            }
+            return restoredLayers;
+        });
+    };
+    /**
+     * Collects entity snapshots on a layer for `LAYDEL` undo.
+     *
+     * @param layerName - Layer whose entities should be snapshotted.
+     * @returns Cloned entities with owner and object ids.
+     */
+    AcApLayerService.prototype.collectLayerEntities = function (layerName) {
+        var e_10, _a, e_11, _b;
+        var snapshots = [];
+        try {
+            for (var _c = __values(this.db.tables.blockTable.newIterator()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var blockRecord = _d.value;
+                try {
+                    for (var _e = (e_11 = void 0, __values(blockRecord.newIterator())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var entity = _f.value;
+                        if (entity.layer !== layerName)
+                            continue;
+                        snapshots.push({
+                            ownerId: blockRecord.objectId,
+                            objectId: entity.objectId,
+                            entity: entity.clone()
+                        });
+                    }
+                }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_11) throw e_11.error; }
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return snapshots;
+    };
+    /**
+     * Removes entities previously captured for `LAYDEL`.
+     *
+     * @param deletedEntities - Entity snapshots to erase from their owners.
+     */
+    AcApLayerService.prototype.removeLayerEntities = function (deletedEntities) {
+        var _this = this;
+        var idsByOwner = new Map();
+        deletedEntities.forEach(function (_a) {
+            var _b;
+            var ownerId = _a.ownerId, objectId = _a.objectId;
+            var ids = (_b = idsByOwner.get(ownerId)) !== null && _b !== void 0 ? _b : [];
+            ids.push(objectId);
+            idsByOwner.set(ownerId, ids);
+        });
+        idsByOwner.forEach(function (ids, ownerId) {
+            var _a;
+            (_a = _this.db.tables.blockTable.getIdAt(ownerId)) === null || _a === void 0 ? void 0 : _a.removeEntity(ids);
+        });
+    };
+    /**
+     * Deletes a layer and all entities on it (`LAYDEL`).
+     *
+     * Layer `0` and the current layer cannot be deleted.
+     *
+     * @param layerName - Name of the layer to delete.
+     * @returns Success with undo snapshots, or a failure reason.
+     */
+    AcApLayerService.prototype.deleteLayer = function (layerName) {
+        var _this = this;
+        var layer = this.db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return { ok: false, reason: 'not_found', layerName: layerName };
+        }
+        if (layer.name === '0') {
+            return { ok: false, reason: 'layer_0', layerName: layerName };
+        }
+        if (layer.name === this.db.clayer) {
+            return { ok: false, reason: 'current_layer', layerName: layerName };
+        }
+        return acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            var deletedEntities = _this.collectLayerEntities(layer.name);
+            _this.removeLayerEntities(deletedEntities);
+            var deletedLayer = layer.clone();
+            _this.db.tables.layerTable.remove(layer.name);
+            _this.db.events.layerErased.dispatch({ database: _this.db, layer: layer });
+            return {
+                ok: true,
+                layerName: layer.name,
+                layer: deletedLayer,
+                entities: deletedEntities
+            };
+        });
+    };
+    /**
+     * Restores a deleted layer and its entities for `LAYDEL` session undo.
+     *
+     * @param layer - Cloned layer table record to re-add.
+     * @param entities - Entity snapshots to append back to their owners.
+     */
+    AcApLayerService.prototype.restoreDeletedLayer = function (layer, entities) {
+        var _this = this;
+        acapRunServiceEdit(this.db, LAYER_EDIT_LABEL, function () {
+            if (!_this.db.tables.layerTable.has(layer.name)) {
+                _this.db.tables.layerTable.add(layer.clone());
+            }
+            var entitiesByOwner = new Map();
+            entities.forEach(function (_a) {
+                var _b;
+                var ownerId = _a.ownerId, entity = _a.entity;
+                var list = (_b = entitiesByOwner.get(ownerId)) !== null && _b !== void 0 ? _b : [];
+                list.push(entity.clone());
+                entitiesByOwner.set(ownerId, list);
+            });
+            entitiesByOwner.forEach(function (list, ownerId) {
+                var _a;
+                var owner = (_a = _this.db.tables.blockTable.getIdAt(ownerId)) !== null && _a !== void 0 ? _a : _this.db.tables.blockTable.modelSpace;
+                owner.appendEntity(list);
+            });
+        });
+    };
+    /**
+     * Restores one layer from an isolation snapshot when its post-isolation state still matches.
+     *
+     * @param snapshot - Per-layer before/after isolation snapshot.
+     * @returns `true` when at least one flag was restored.
+     */
+    AcApLayerService.prototype.restoreLayerIfUnchanged = function (snapshot) {
+        var layer = this.db.tables.layerTable.getAt(snapshot.name);
+        if (!layer)
+            return false;
+        var opened = AcApLayerService.openLayerForWrite(this.db, layer);
+        if (!opened)
+            return false;
+        var restored = false;
+        if (opened.isOff === snapshot.isolated.isOff &&
+            opened.isOff !== snapshot.before.isOff) {
+            opened.isOff = snapshot.before.isOff;
+            restored = true;
+        }
+        if (opened.isFrozen === snapshot.isolated.isFrozen &&
+            opened.isFrozen !== snapshot.before.isFrozen) {
+            AcApLayerService.setLayerFrozenState(opened, snapshot.before.isFrozen);
+            restored = true;
+        }
+        if (AcApLayerService.isLayerLocked(opened) === snapshot.isolated.isLocked &&
+            AcApLayerService.isLayerLocked(opened) !== snapshot.before.isLocked) {
+            AcApLayerService.setLayerLockedState(opened, snapshot.before.isLocked);
+            restored = true;
+        }
+        return restored;
+    };
+    /**
+     * Resolves live layer-table traits for rendering and style synchronization.
+     *
+     * @param layerName - Name of the layer to resolve from the layer table.
+     * @returns Resolved sub-entity traits, or undefined when the layer is missing.
+     */
+    AcApLayerService.prototype.getEffectiveLayerTraits = function (layerName) {
+        return AcApLayerService.resolveLayerTraits(this.db, layerName);
+    };
+    /**
+     * Resolves live layer-table traits from the given database.
+     *
+     * @param db - Database whose layer table supplies the record.
+     * @param layerName - Name of the layer to resolve.
+     * @returns Resolved sub-entity traits, or undefined when the layer is missing.
+     */
+    AcApLayerService.resolveLayerTraits = function (db, layerName) {
+        var layer = db.tables.layerTable.getAt(layerName);
+        if (!layer) {
+            return undefined;
+        }
+        return {
+            layer: layer.name,
+            color: layer.color.clone(),
+            lineType: layer.lineStyle,
+            lineWeight: layer.lineWeight,
+            transparency: layer.transparency
+        };
+    };
+    return AcApLayerService;
+}());
+export { AcApLayerService };
+//# sourceMappingURL=AcApLayerService.js.map