@mlightcad/cad-simple-viewer 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/smartBlock/AcApSmartBlockSearch.js

@@ -0,0 +1,712 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.");
+};
+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));
+};
+import { AcDbBlockReference, AcGeBox2d } from '@mlightcad/data-model';
+import { excludeLockedLayerIds } from '../service/AcApLockedLayer';
+import { acedEntityToShapeFeature } from './AcEdShapeFeatures';
+import { acedFindShapeMatches, AcEdShapeGridCache } from './AcEdShapeMatcher';
+/**
+ * Caches entity features for one search session, so changing review
+ * filters does not describe the whole drawing again. Features are stored
+ * without the layer prefix; layer matching is applied on read.
+ */
+var AcApSmartBlockFeatureCache = /** @class */ (function () {
+    function AcApSmartBlockFeatureCache() {
+        this.raw = new Map();
+        this.layered = new Map();
+    }
+    /**
+     * Feature of `entity`, or `undefined` when matching cannot describe it.
+     *
+     * @param entity - Entity to describe.
+     * @param matchLayer - Prefix the kind with the layer name.
+     */
+    AcApSmartBlockFeatureCache.prototype.get = function (entity, matchLayer) {
+        var _a;
+        var feature = this.raw.get(entity.objectId);
+        if (feature === undefined) {
+            feature =
+                (_a = acedEntityToShapeFeature(entity, entity.objectId, {
+                    matchLayer: false
+                })) !== null && _a !== void 0 ? _a : null;
+            this.raw.set(entity.objectId, feature);
+        }
+        if (!feature || !matchLayer)
+            return feature !== null && feature !== void 0 ? feature : undefined;
+        // Layered copies are cached too: detection searches many times.
+        var layered = this.layered.get(entity.objectId);
+        if (!layered || layered.kind !== "".concat(entity.layer, "|").concat(feature.kind)) {
+            layered = __assign(__assign({}, feature), { kind: "".concat(entity.layer, "|").concat(feature.kind) });
+            this.layered.set(entity.objectId, layered);
+        }
+        return layered;
+    };
+    return AcApSmartBlockFeatureCache;
+}());
+export { AcApSmartBlockFeatureCache };
+/**
+ * Shapes a search may use, grouped by kind. Usually every visible,
+ * describable model-space shape not on a locked layer
+ * ({@link AcApSmartBlockCandidatePool.fromDatabase}); build it once to run
+ * many searches over an unchanged drawing. Detection also builds small
+ * pools around the places copies can be. A search without a pool builds
+ * the full one.
+ */
+var AcApSmartBlockCandidatePool = /** @class */ (function () {
+    /**
+     * @param features - Shapes to search among; kinds must already carry the
+     * layer prefix when layers are matched.
+     */
+    function AcApSmartBlockCandidatePool(features) {
+        var e_1, _a;
+        /** Spatial indexes shared by the searches over this pool. */
+        this.gridCache = new AcEdShapeGridCache();
+        this.byKind = new Map();
+        this.byId = new Map();
+        try {
+            for (var features_1 = __values(features), features_1_1 = features_1.next(); !features_1_1.done; features_1_1 = features_1.next()) {
+                var feature = features_1_1.value;
+                this.byId.set(feature.id, feature);
+                var list = this.byKind.get(feature.kind);
+                if (list)
+                    list.push(feature);
+                else
+                    this.byKind.set(feature.kind, [feature]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (features_1_1 && !features_1_1.done && (_a = features_1.return)) _a.call(features_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    /**
+     * Pool of every visible, describable model-space shape that is not on a
+     * locked layer.
+     *
+     * @param db - Drawing database.
+     * @param matchLayer - Prefix kinds with the layer name.
+     * @param cache - Feature cache to fill and reuse.
+     */
+    AcApSmartBlockCandidatePool.fromDatabase = function (db, matchLayer, cache) {
+        var e_2, _a;
+        if (cache === void 0) { cache = new AcApSmartBlockFeatureCache(); }
+        var features = new Map();
+        try {
+            for (var _b = __values(db.tables.blockTable.modelSpace.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                if (!entity.visibility)
+                    continue;
+                var feature = cache.get(entity, matchLayer);
+                if (feature)
+                    features.set(entity.objectId, feature);
+            }
+        }
+        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 new AcApSmartBlockCandidatePool(excludeLockedLayerIds(db, __spreadArray([], __read(features.keys()), false)).ids.map(function (id) { return features.get(id); }));
+    };
+    /** Shapes of one kind. */
+    AcApSmartBlockCandidatePool.prototype.ofKind = function (kind) {
+        var _a;
+        return (_a = this.byKind.get(kind)) !== null && _a !== void 0 ? _a : [];
+    };
+    /** Feature of a pooled shape. */
+    AcApSmartBlockCandidatePool.prototype.feature = function (id) {
+        return this.byId.get(id);
+    };
+    return AcApSmartBlockCandidatePool;
+}());
+export { AcApSmartBlockCandidatePool };
+/**
+ * Builds the search template from selected entity ids.
+ *
+ * @param db - Drawing database.
+ * @param ids - Selected entity ids.
+ * @param options - Search options (layer matching).
+ */
+export function acapBuildSmartBlockTemplate(db, ids, options) {
+    var e_3, _a;
+    if (options === void 0) { options = {}; }
+    var blockTable = db.tables.blockTable;
+    var template = {
+        entities: [],
+        ids: [],
+        unsupportedIds: [],
+        features: [],
+        texts: []
+    };
+    var featureOptions = toFeatureOptions(options);
+    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;
+            var entity = blockTable.getEntityById(id);
+            if (!entity)
+                continue;
+            var feature = acedEntityToShapeFeature(entity, id, featureOptions);
+            if (!feature) {
+                template.unsupportedIds.push(id);
+                continue;
+            }
+            template.entities.push(entity);
+            template.ids.push(id);
+            template.features.push(feature);
+            template.texts.push(feature.label);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return template;
+}
+/**
+ * Finds every copy of `template` in model space.
+ *
+ * Loose-geometry copies come from {@link acedFindShapeMatches}. With
+ * `includeExistingBlocks`, references of blocks whose definition is the same
+ * geometry are reported as well. Shapes on locked layers are never matched,
+ * since they could not be replaced.
+ *
+ * @param db - Drawing database.
+ * @param template - Template from {@link acapBuildSmartBlockTemplate}.
+ * @param options - Search options.
+ * @returns Matches sorted by position (left to right, then bottom to top).
+ */
+export function acapFindSmartBlockMatches(db, template, options, cache, pool) {
+    var e_4, _a;
+    var _b, _c, _d;
+    if (options === void 0) { options = {}; }
+    if (cache === void 0) { cache = new AcApSmartBlockFeatureCache(); }
+    if (template.entities.length === 0)
+        return [];
+    var matchLayer = (_b = options.matchLayer) !== null && _b !== void 0 ? _b : true;
+    var textVariations = (_c = options.textVariations) !== null && _c !== void 0 ? _c : true;
+    // Rebuilt per search: layer matching may have been toggled since the
+    // template was built.
+    var templateFeatures = template.entities.map(function (entity) { return cache.get(entity, matchLayer); });
+    // Like AutoCAD, selected single-line texts do not take part in the
+    // geometry match: texts with other strings (room numbers, axis labels)
+    // are rarely placed at exactly the same spot, e.g. left-aligned "1" and
+    // "10" start at different points. Geometry fixes the transform; each
+    // template text then picks up the text found at its place in the copy.
+    // A template made of texts only is matched as plain shapes.
+    var textIndices = [];
+    var shapeIndices = [];
+    templateFeatures.forEach(function (f, i) {
+        return (f.label === undefined ? shapeIndices : textIndices).push(i);
+    });
+    if (shapeIndices.length === 0)
+        textIndices.length = 0;
+    var shapeFeatures = shapeIndices.map(function (i) { return templateFeatures[i]; });
+    var templateIds = new Set(template.ids);
+    var shapeKinds = new Set(shapeFeatures.map(function (f) { return f.kind; }));
+    var textKinds = new Set(textIndices.map(function (i) { return templateFeatures[i].kind; }));
+    var source = pool !== null && pool !== void 0 ? pool : AcApSmartBlockCandidatePool.fromDatabase(db, matchLayer, cache);
+    var ofKinds = function (kinds) {
+        return __spreadArray([], __read(kinds), false).flatMap(function (kind) { return source.ofKind(kind); });
+    };
+    // Only shapes of the template's kinds can take part in a copy. The
+    // matcher skips the template's own shapes itself.
+    var candidates = ofKinds(shapeKinds);
+    var textCandidates = textIndices.length > 0
+        ? ofKinds(textKinds).filter(function (f) { return !templateIds.has(f.id); })
+        : [];
+    var candidateFeatures = { get: function (id) { return source.feature(id); } };
+    var texts = new TextPicker(db, textIndices.map(function (i) { return ({
+        entity: template.entities[i],
+        feature: templateFeatures[i]
+    }); }), textCandidates, textVariations);
+    var textIdsOf = new Map();
+    var shapeMatches = acedFindShapeMatches(shapeFeatures, candidates, {
+        tolerance: options.tolerance,
+        allowRotation: options.allowRotation,
+        allowMirror: options.allowMirror,
+        allowScale: options.allowScale,
+        ignoreLabels: textVariations,
+        gridCache: pool === null || pool === void 0 ? void 0 : pool.gridCache,
+        // A copy must hold every selected text at its place. Checked inside the
+        // search so symmetric geometry tries the transform that fits the texts.
+        accept: function (match) {
+            var ids = texts.pick(match);
+            if (ids)
+                textIdsOf.set(match, ids);
+            return !!ids;
+        }
+    });
+    var matches = [];
+    var _loop_1 = function (match) {
+        var textIds = (_d = textIdsOf.get(match)) !== null && _d !== void 0 ? _d : [];
+        var ids = new Array(templateFeatures.length);
+        shapeIndices.forEach(function (index, i) { return (ids[index] = match.ids[i]); });
+        textIndices.forEach(function (index, i) { return (ids[index] = textIds[i]); });
+        matches.push(__assign(__assign({}, match), { ids: ids, included: true, texts: templateFeatures.map(function (f, i) { var _a; return f.label === undefined ? undefined : (_a = candidateFeatures.get(ids[i])) === null || _a === void 0 ? void 0 : _a.label; }) }));
+    };
+    try {
+        for (var shapeMatches_1 = __values(shapeMatches), shapeMatches_1_1 = shapeMatches_1.next(); !shapeMatches_1_1.done; shapeMatches_1_1 = shapeMatches_1.next()) {
+            var match = shapeMatches_1_1.value;
+            _loop_1(match);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (shapeMatches_1_1 && !shapeMatches_1_1.done && (_a = shapeMatches_1.return)) _a.call(shapeMatches_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    if (options.includeExistingBlocks) {
+        matches.push.apply(matches, __spreadArray([], __read(findBlockReferenceMatches(db, template, options)), false));
+    }
+    var origin = matchOrigin(template);
+    var keyOf = function (m) { return applyAffine(m.transform, origin); };
+    return matches.sort(function (a, b) {
+        var pa = keyOf(a);
+        var pb = keyOf(b);
+        return Math.abs(pa.x - pb.x) > 1e-9 ? pa.x - pb.x : pa.y - pb.y;
+    });
+}
+/**
+ * Lists blocks whose definition is the template geometry (same shapes and
+ * nothing else), up to rotation, mirroring and uniform scale. Layers are not
+ * compared since block content usually lives on layer `0`.
+ *
+ * @param db - Drawing database.
+ * @param template - Template from {@link acapBuildSmartBlockTemplate}.
+ */
+export function acapFindEquivalentBlocks(db, template, options) {
+    var e_5, _a, e_6, _b;
+    var _c;
+    if (options === void 0) { options = {}; }
+    var result = [];
+    if (template.entities.length === 0)
+        return result;
+    var featureOptions = { matchLayer: false };
+    var templateFeatures = template.entities.map(function (entity, i) {
+        return acedEntityToShapeFeature(entity, template.ids[i], featureOptions);
+    });
+    try {
+        for (var _d = __values(db.tables.blockTable.newIterator()), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var record = _e.value;
+            if (!isUserBlock(record))
+                continue;
+            // Cheap size check before describing the definition.
+            var entities = __spreadArray([], __read(record.newIterator()), false);
+            if (entities.length !== templateFeatures.length)
+                continue;
+            var features = [];
+            try {
+                for (var entities_1 = (e_6 = void 0, __values(entities)), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
+                    var entity = entities_1_1.value;
+                    var feature = acedEntityToShapeFeature(entity, entity.objectId, featureOptions);
+                    if (!feature)
+                        break;
+                    features.push(feature);
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (entities_1_1 && !entities_1_1.done && (_b = entities_1.return)) _b.call(entities_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            if (features.length !== templateFeatures.length)
+                continue;
+            var _f = __read(acedFindShapeMatches(templateFeatures, features, {
+                allowRotation: true,
+                allowMirror: true,
+                allowScale: true,
+                ignoreLabels: (_c = options.textVariations) !== null && _c !== void 0 ? _c : true
+            }), 1), match = _f[0];
+            if (match)
+                result.push({ blockName: record.name, transform: match.transform });
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return result;
+}
+/**
+ * Center of the template's extents: AutoCAD's default insertion point for a
+ * new block.
+ */
+export function acapSmartBlockTemplateCenter(template) {
+    var e_7, _a;
+    var box = new AcGeBox2d();
+    try {
+        for (var _b = __values(template.entities), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entity = _c.value;
+            var ext = entity.geometricExtents;
+            if (ext.isEmpty())
+                continue;
+            box.expandByPoint(ext.min);
+            box.expandByPoint(ext.max);
+        }
+    }
+    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; }
+    }
+    if (box.isEmpty())
+        return matchOrigin(template);
+    return {
+        x: (box.min.x + box.max.x) / 2,
+        y: (box.min.y + box.max.y) / 2
+    };
+}
+/**
+ * Indices of template texts whose string differs in at least one included
+ * instance; these become attributes when converting with text variations.
+ */
+export function acapSmartBlockVariableTexts(template, matches) {
+    var indices = [];
+    template.texts.forEach(function (text, i) {
+        if (text === undefined)
+            return;
+        var varies = matches.some(function (m) { return m.included && !m.blockReference && m.texts[i] !== text; });
+        if (varies)
+            indices.push(i);
+    });
+    return indices;
+}
+/** Composes two affine maps: `outer ∘ inner`. */
+export function acapComposeAffine2d(outer, inner) {
+    return {
+        a: outer.a * inner.a + outer.c * inner.b,
+        b: outer.b * inner.a + outer.d * inner.b,
+        c: outer.a * inner.c + outer.c * inner.d,
+        d: outer.b * inner.c + outer.d * inner.d,
+        e: outer.a * inner.e + outer.c * inner.f + outer.e,
+        f: outer.b * inner.e + outer.d * inner.f + outer.f
+    };
+}
+/** Splits a similarity map into rotation, uniform scale and mirroring. */
+export function acapDecomposeAffine2d(t) {
+    var det = t.a * t.d - t.b * t.c;
+    return {
+        rotation: Math.atan2(t.b, t.a),
+        scale: Math.sqrt(Math.abs(det)),
+        mirrored: det < 0
+    };
+}
+function findBlockReferenceMatches(db, template, options) {
+    var e_8, _a, e_9, _b;
+    var _c;
+    var equivalents = acapFindEquivalentBlocks(db, template, options);
+    if (equivalents.length === 0)
+        return [];
+    var byName = new Map(equivalents.map(function (b) { return [b.blockName, b]; }));
+    var templateIds = new Set(template.ids);
+    var refIds = [];
+    var refs = new Map();
+    try {
+        for (var _d = __values(db.tables.blockTable.modelSpace.newIterator()), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var entity = _e.value;
+            if (!(entity instanceof AcDbBlockReference))
+                continue;
+            if (templateIds.has(entity.objectId) || !byName.has(entity.blockName)) {
+                continue;
+            }
+            refIds.push(entity.objectId);
+            refs.set(entity.objectId, entity);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    var matches = [];
+    try {
+        for (var _f = __values(excludeLockedLayerIds(db, refIds).ids), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var id = _g.value;
+            var ref = refs.get(id);
+            var e = ref.blockTransform.elements;
+            var refAffine = {
+                a: e[0],
+                b: e[1],
+                c: e[4],
+                d: e[5],
+                e: e[12],
+                f: e[13]
+            };
+            var transform = acapComposeAffine2d(refAffine, byName.get(ref.blockName).transform);
+            var parts = acapDecomposeAffine2d(transform);
+            // Non-uniformly scaled references are not a similarity of the template.
+            var sx = Math.hypot(transform.a, transform.b);
+            var sy = Math.hypot(transform.c, transform.d);
+            if (Math.abs(sx - sy) > 1e-6 * Math.max(sx, sy, 1))
+                continue;
+            if (!options.allowScale && Math.abs(parts.scale - 1) > 1e-6)
+                continue;
+            if (!((_c = options.allowMirror) !== null && _c !== void 0 ? _c : true) && parts.mirrored)
+                continue;
+            matches.push(__assign(__assign({}, parts), { transform: transform, ids: [id], included: true, blockReference: true, texts: template.texts.map(function () { return undefined; }) }));
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return matches;
+}
+function isUserBlock(record) {
+    var name = record.name;
+    if (!name || name.startsWith('*'))
+        return false;
+    if (record.isModelSapce || record.isPaperSapce)
+        return false;
+    // External references are not editable definitions.
+    return !record.isXref;
+}
+function toFeatureOptions(options) {
+    var _a;
+    return {
+        matchLayer: (_a = options.matchLayer) !== null && _a !== void 0 ? _a : true,
+        includeBlockReferences: true
+    };
+}
+function matchOrigin(template) {
+    var _a, _b;
+    return (_b = (_a = template.features[0]) === null || _a === void 0 ? void 0 : _a.center) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
+}
+function applyAffine(t, p) {
+    return { x: t.a * p.x + t.c * p.y + t.e, y: t.b * p.x + t.d * p.y + t.f };
+}
+/**
+ * Pairs the template texts with the texts of a geometry copy.
+ *
+ * A text belongs to a copy when it lies where the template text lands under
+ * the copy's transform: its extents center within one text height, with
+ * the same height and orientation (mirrored copies may keep their text
+ * readable, as with `MIRRTEXT` = 0). Extents centers rather than insertion
+ * points are compared so differently long strings still pair up. Strings
+ * must be equal unless text variations are searched. Each text belongs to
+ * one copy only.
+ */
+var TextPicker = /** @class */ (function () {
+    /**
+     * @param db - Drawing database.
+     * @param texts - Template texts with their features (search layer mode).
+     * @param candidates - Text features the copies may use.
+     * @param ignoreLabels - Accept texts with other strings.
+     */
+    function TextPicker(db, texts, candidates, ignoreLabels) {
+        var e_10, _a, e_11, _b;
+        this.ignoreLabels = ignoreLabels;
+        this.byKind = new Map();
+        this.claimed = new Set();
+        var blockTable = db.tables.blockTable;
+        this.templateTexts = texts.map(function (_a) {
+            var entity = _a.entity, feature = _a.feature;
+            return ({
+                feature: feature,
+                center: textCenter(entity, feature)
+            });
+        });
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var feature = candidates_1_1.value;
+                var entity = blockTable.getEntityById(feature.id);
+                var candidate = {
+                    feature: feature,
+                    center: entity ? textCenter(entity, feature) : feature.center
+                };
+                var list = this.byKind.get(feature.kind);
+                if (list)
+                    list.push(candidate);
+                else
+                    this.byKind.set(feature.kind, [candidate]);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        try {
+            // Sorted by x so a lookup only scans a narrow band.
+            for (var _c = __values(this.byKind.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var list = _d.value;
+                list.sort(function (a, b) { return a.center.x - b.center.x; });
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    }
+    /**
+     * Ids of the copy's texts in template text order, or `undefined` when a
+     * template text has no counterpart. Found texts are claimed.
+     */
+    TextPicker.prototype.pick = function (match) {
+        var e_12, _a;
+        var _this = this;
+        var ids = [];
+        var taken = new Set();
+        try {
+            for (var _b = __values(this.templateTexts), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var source = _c.value;
+                var found = this.find(source, match, taken);
+                if (!found)
+                    return undefined;
+                ids.push(found);
+                taken.add(found);
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        ids.forEach(function (id) { return _this.claimed.add(id); });
+        return ids;
+    };
+    TextPicker.prototype.find = function (source, match, taken) {
+        var _a, _b;
+        var list = this.byKind.get(source.feature.kind);
+        if (!list)
+            return undefined;
+        var t = match.transform;
+        var f = source.feature;
+        var scale = match.scale;
+        var height = f.size * scale;
+        var radius = Math.max(height, 1e-9);
+        var center = applyAffine(t, source.center);
+        var dir = textDirection(f);
+        var mapped = normalize({
+            x: t.a * dir.x + t.c * dir.y,
+            y: t.b * dir.x + t.d * dir.y
+        });
+        var cosTol = Math.cos((2 * Math.PI) / 180);
+        var best;
+        var bestDist = radius;
+        var lo = 0;
+        var hi = list.length;
+        while (lo < hi) {
+            var mid = (lo + hi) >> 1;
+            if (list[mid].center.x < center.x - radius)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        for (var k = lo; k < list.length; k++) {
+            var c = list[k];
+            if (c.center.x > center.x + radius)
+                break;
+            var g = c.feature;
+            if (this.claimed.has(g.id) || taken.has(g.id))
+                continue;
+            if (!this.ignoreLabels && ((_a = g.label) !== null && _a !== void 0 ? _a : '') !== ((_b = f.label) !== null && _b !== void 0 ? _b : ''))
+                continue;
+            if (Math.abs(g.size - height) > Math.max(height * 0.02, 1e-9))
+                continue;
+            var d = Math.hypot(c.center.x - center.x, c.center.y - center.y);
+            if (d > bestDist)
+                continue;
+            var v = textDirection(g);
+            var dot = v.x * mapped.x + v.y * mapped.y;
+            if (dot < cosTol && !(match.mirrored && dot <= -cosTol))
+                continue;
+            best = g.id;
+            bestDist = d;
+        }
+        return best;
+    };
+    return TextPicker;
+}());
+/** Center of a text's extents; its insertion point when they are empty. */
+function textCenter(entity, feature) {
+    var ext = entity.geometricExtents;
+    if (ext.isEmpty())
+        return feature.center;
+    return { x: (ext.min.x + ext.max.x) / 2, y: (ext.min.y + ext.max.y) / 2 };
+}
+/** Unit baseline direction of a text feature. */
+function textDirection(feature) {
+    var _a = __read(feature.points, 2), p0 = _a[0], p1 = _a[1];
+    if (!p0 || !p1)
+        return { x: 1, y: 0 };
+    return normalize({ x: p1.x - p0.x, y: p1.y - p0.y });
+}
+function normalize(v) {
+    var len = Math.hypot(v.x, v.y);
+    return len > 0 ? { x: v.x / len, y: v.y / len } : { x: 1, y: 0 };
+}
+//# sourceMappingURL=AcApSmartBlockSearch.js.map