w-web-perm 1.1.12 → 1.1.13

package/src/js/fromAudit.mjs

@@ -0,0 +1,417 @@
+import { isExternalRow } from './externalRows.mjs'
+import { REF_OF, planRefChanges } from './refCascade.mjs'
+import { getDelImpact } from './getDelRefCount.mjs'
+
+
+//來源欄 from 之稽核、型別正規化與「整來源清除」規劃(run07 升版維運工具之核心; F-23 外部列受保護、規則帳本 R-PRINCIPLE-00 原則 5):
+//  外部列＝from 為非空字串者(externalRows.isExternalRow, 單一擁有者, 本檔不另寫判準); from 為 ''、缺欄、非字串(null／數字／布林／物件)者為後台列.
+//  升版後外部列於後台唯讀(不得改、不得刪), 故升版前舊資料之「非空 from」列將成為唯讀; 非字串 from 後台寫入起被拒收.
+//本檔為純函數(不依賴 Vue／DOM／ORM／fs), 供離線維運腳本 g_fixFromType.mjs／g_purgeFrom.mjs(經 server/tools/fromTools.mjs)與單元測試共用;
+//所有函數不改輸入; 輸出之 id 與名稱僅供離線工具列印於 stdout, 不得寫入 srLog(規則帳本: 日誌不記 id／個資).
+
+
+//TABLE_ORDER: 四表依引用鏈序(被引用者先、引用端後; 同 server/keyCheck.mjs 之 TAB_LOCK_RANK): 標的 → 權限 → 群組 → 使用者
+const TABLE_ORDER = ['targets', 'pemis', 'grups', 'users']
+
+//NON_STRING_KINDS: 非字串 from 之型別分類(null／number／boolean／object／array／other)
+const NON_STRING_KINDS = ['null', 'number', 'boolean', 'object', 'array', 'other']
+
+//KIND_ORDER: 稽核結果內 from 值分類之固定輸出次序(empty: ''、missing: 缺欄(視同 '')、非字串各型、notObject: 列本身非物件, 最後為非空字串依值分組)
+const KIND_ORDER = ['empty', 'missing', ...NON_STRING_KINDS, 'notObject']
+
+//IMPACT_KIND: 清除之表 → getDelImpact 之種類(AND 引用者數之口徑, 同清單頁刪除確認框); targets 之 crules 無 mode、users 無引用端, 不適用
+const IMPACT_KIND = { grups: 'Grup', pemis: 'Pemi' }
+
+
+let isStr = (v) => typeof v === 'string'
+let hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
+let isObj = (v) => v !== null && typeof v === 'object'
+let arr = (v) => (Array.isArray(v) ? v : [])
+let hasId = (r) => isObj(r) && isStr(r.id) && r.id !== '' //可寫回／可刪除之列須有非空字串主鍵(ORM 以字串主鍵定位)
+let strCmp = (a, b) => (a < b ? -1 : (a > b ? 1 : 0)) //依 UTF-16 碼元之確定性比較(不隨 locale)
+
+
+//fromKind: 列之 from 值分類 { kind, from? }; 非空字串之判準經 isExternalRow(單一擁有者), from 僅 kind 為 'string' 時給
+let fromKind = (row) => {
+    if (!isObj(row)) {
+        return { kind: 'notObject' }
+    }
+    if (isExternalRow(row)) {
+        return { kind: 'string', from: row.from }
+    }
+    let v = row.from
+    if (v === undefined) {
+        return { kind: 'missing' }
+    }
+    if (v === '') {
+        return { kind: 'empty' }
+    }
+    if (v === null) {
+        return { kind: 'null' }
+    }
+    if (typeof v === 'number') {
+        return { kind: 'number' }
+    }
+    if (typeof v === 'boolean') {
+        return { kind: 'boolean' }
+    }
+    if (Array.isArray(v)) {
+        return { kind: 'array' }
+    }
+    if (typeof v === 'object') {
+        return { kind: 'object' }
+    }
+    return { kind: 'other' }
+}
+
+
+//newKinds: 非字串各型之計數容器
+let newKinds = () => Object.fromEntries(NON_STRING_KINDS.map((k) => [k, 0]))
+
+
+/**
+ * 稽核四表 from 欄之分佈(純函數, 不讀寫任何資料)
+ *
+ * from 值分類: ''(empty)、缺欄(missing, 視同 '')、非字串(null／number／boolean／object／array／other, 各記型別)、非空字串(string, 依值分組, 精確 ===, 不 trim、不分大小寫);
+ * 列本身非物件者記 notObject. 非空字串者為「升版後將成為外部列(唯讀)」, 列入 external.
+ *
+ * @param {Object} d 輸入 { users, grups, pemis, targets }(各為列陣列, 缺者視為空)
+ * @returns {Object} 回傳 { entries, external, counts }:
+ *   entries   [{ table, kind, n }]（kind 為 'string' 者另帶 from 值）, 依 TABLE_ORDER 與 KIND_ORDER 輸出, 非空字串依 from 值升冪; 只列 n 大於 0 者
+ *   external  [{ table, from, n }] 升版後將成為外部列(唯讀)之(表, from)與筆數
+ *   counts    { nRows, nEmpty, nMissing, nNonString, nExternal, nNotObject, nSources, byTable: { 表: { nRows, nEmpty, nMissing, nNonString, nExternal, nNotObject, nSources, kinds } } }
+ * @example
+ *
+ * let r = auditFrom({ users: [{ id: 'u1', from: '' }, { id: 'u2', from: 'pd' }, { id: 'u3', from: null }] })
+ * console.log(r.external, r.counts.nNonString)
+ * // => [ { table: 'users', from: 'pd', n: 1 } ] 1
+ *
+ */
+function auditFrom(d) {
+    let data = isObj(d) ? d : {}
+    let entries = []
+    let external = []
+    let byTable = {}
+    let counts = { nRows: 0, nEmpty: 0, nMissing: 0, nNonString: 0, nExternal: 0, nNotObject: 0, nSources: 0, byTable }
+
+    for (let t of TABLE_ORDER) {
+        let rows = arr(data[t])
+        let tab = { nRows: rows.length, nEmpty: 0, nMissing: 0, nNonString: 0, nExternal: 0, nNotObject: 0, nSources: 0, kinds: newKinds() }
+        let nOf = new Map() //kind → 筆數
+        let srcs = new Map() //from 值 → 筆數(Map: 值可為 __proto__ 等任意字串)
+        for (let row of rows) {
+            let k = fromKind(row)
+            if (k.kind === 'string') {
+                srcs.set(k.from, (srcs.get(k.from) || 0) + 1)
+            }
+            else {
+                nOf.set(k.kind, (nOf.get(k.kind) || 0) + 1)
+            }
+        }
+        for (let kind of KIND_ORDER) {
+            let n = nOf.get(kind) || 0
+            if (n === 0) {
+                continue
+            }
+            entries.push({ table: t, kind, n })
+            if (kind === 'empty') {
+                tab.nEmpty = n
+            }
+            else if (kind === 'missing') {
+                tab.nMissing = n
+            }
+            else if (kind === 'notObject') {
+                tab.nNotObject = n
+            }
+            else {
+                tab.kinds[kind] = n
+                tab.nNonString += n
+            }
+        }
+        for (let from of [...srcs.keys()].sort(strCmp)) {
+            let n = srcs.get(from)
+            entries.push({ table: t, kind: 'string', from, n })
+            external.push({ table: t, from, n })
+            tab.nExternal += n
+            tab.nSources++
+        }
+        byTable[t] = tab
+        for (let key of ['nRows', 'nEmpty', 'nMissing', 'nNonString', 'nExternal', 'nNotObject', 'nSources']) {
+            counts[key] += tab[key]
+        }
+    }
+    return { entries, external, counts }
+}
+
+
+/**
+ * 規劃「把非字串 from 正規化為 ''」(g_fixFromType 之核心; 純函數, 不改輸入)
+ *
+ * 待改列: from 為 null／數字／布林／物件／陣列等非字串者, 改為 ''(後台列; 與缺欄、'' 同為後台列, 故不改變任何列是否為外部列).
+ * 缺欄視同 ''(已是後台列), 不改, 只列出其 id; 非空字串為外部列, 不動; 缺非空字串主鍵而無從寫回者列入 noId(不改, 須人工處理).
+ *
+ * @param {Array} rows 輸入某一表之全部列
+ * @returns {Object} 回傳 { changes, missing, noId, counts }:
+ *   changes  [{ id, kind, before, after }] 待改列, after 恆為 ''; before 為原 from 值(原樣, 同輸入之參考)
+ *   missing  缺 from 欄之列之 id 陣列(只列出, 不改)
+ *   noId     [{ idx, kind }] 非字串 from 而缺非空字串主鍵者(idx 為其於輸入陣列之索引)
+ *   counts   { nRows, nEmpty, nMissing, nNonString, nExternal, nNotObject, nNoId, kinds }
+ * @example
+ *
+ * let r = planFixFromType([{ id: 'a', from: null }, { id: 'b', from: 'pd' }, { id: 'c' }])
+ * console.log(r.changes, r.missing)
+ * // => [ { id: 'a', kind: 'null', before: null, after: '' } ] [ 'c' ]
+ *
+ */
+function planFixFromType(rows) {
+    let src = arr(rows)
+    let res = { changes: [], missing: [], noId: [], counts: { nRows: src.length, nEmpty: 0, nMissing: 0, nNonString: 0, nExternal: 0, nNotObject: 0, nNoId: 0, kinds: newKinds() } }
+    let c = res.counts
+    src.forEach((row, idx) => {
+        let k = fromKind(row)
+        if (k.kind === 'empty') {
+            c.nEmpty++
+        }
+        else if (k.kind === 'string') {
+            c.nExternal++
+        }
+        else if (k.kind === 'notObject') {
+            c.nNotObject++
+        }
+        else if (k.kind === 'missing') {
+            c.nMissing++
+            if (hasId(row)) {
+                res.missing.push(row.id)
+            }
+        }
+        else {
+            c.nNonString++
+            c.kinds[k.kind]++
+            if (hasId(row)) {
+                res.changes.push({ id: row.id, kind: k.kind, before: row.from, after: '' })
+            }
+            else {
+                c.nNoId++
+                res.noId.push({ idx, kind: k.kind })
+            }
+        }
+    })
+    return res
+}
+
+
+//rowName: 列之顯示名稱(僅供離線輸出; targets 之 id 即名稱; users 不輸出名稱——姓名為個資, 同 authRefsAudit 不回顯 email／name 之慣例)
+let rowName = (keyTable, r) => {
+    if (keyTable === 'users') {
+        return undefined
+    }
+    if (keyTable === 'targets') {
+        return isStr(r.id) ? r.id : ''
+    }
+    return isStr(r.name) ? r.name : ''
+}
+
+
+//similarFroms: 與指定 from 不相同但「去前後空白並忽略大小寫後相同」之來源(僅提示, 不納入清除; 防手誤, 如 'PD' 與 'pd'、'pd ' 與 'pd')
+let similarFroms = (rows, from) => {
+    let want = from.trim().toLowerCase()
+    let m = new Map()
+    for (let r of rows) {
+        if (isExternalRow(r) && r.from !== from && r.from.trim().toLowerCase() === want) {
+            m.set(r.from, (m.get(r.from) || 0) + 1)
+        }
+    }
+    return [...m.keys()].sort(strCmp).map((f) => ({ from: f, n: m.get(f) }))
+}
+
+
+/**
+ * 規劃「整來源清除」: 某表 from 精確等於指定值之全部列, 連同同一次清理引用之計畫(g_purgeFrom 之核心; 純函數, 不改輸入, 不讀寫任何資料)
+ *
+ * 被清除列 ＝ 該表 `row.from === from`(精確 ===, 不 trim、不忽略大小寫、不模糊); from 須為非空字串, 拒絕 ''、非字串(err 'invalidFrom'); 表名須為 targets／pemis／grups／users(err 'invalidTable').
+ * 被清除列缺非空字串主鍵而無從刪除者整體拒絕(err 'purgeRowNoId', 零寫入, 不做部分清除).
+ * targets／pemis／grups 之清除另以 refCascade.planRefChanges 規劃「同一次清理引用」(引用端 pemis.crules／grups.cpemis／users.cgrups; rowsNew ＝ 該表扣除被清除列, holdersOld 為引用端全表),
+ * 效果同後台刪除該些列(身分以主鍵 id; 歷史同名仍有存續列者不清理); 計畫有 err(如 renameCascadeUnsupported: 引用端含無法安全重新編碼之內容)則整體拒絕、零寫入.
+ * users 之清除無引用清理.
+ *
+ * @param {Object} p 輸入參數物件
+ * @param {String} p.keyTable 輸入被清除之表('targets'、'pemis'、'grups' 或 'users')
+ * @param {String} p.from 輸入來源名稱(非空字串, 精確比對)
+ * @param {Object} p.tables 輸入 { users, grups, pemis, targets }(各為該表全部列; 引用端表須一併給)
+ * @returns {Object} 回傳 { err, keyTable, from, holder, field, rows, delIds, nRows, nAdmin, nNoId, changes, delNames, nHolders, nDelHolders, nExternal, impact, similar }:
+ *   err        null 或拒絕原因鍵(invalidTable／invalidFrom／purgeRowNoId／planRefChanges 之 err, 如 renameCascadeUnsupported); 非 null 時 changes 為空(零寫入)
+ *   rows       [{ id, name? }] 被清除列(id 與名稱僅供離線輸出; users 無 name); delIds 為其 id 陣列; nRows 為其筆數; nAdmin 為其中 isAdmin 為 'y' 者(僅 users)
+ *   changes    引用端改寫 [{ id, field, before, after, nRename, nDel, from }](依 planRefChanges); holder／field 為引用端表與欄位(users 清除為空字串)
+ *   delNames   須清理之被清除名稱(planRefChanges.delNames); nHolders 為須改寫之引用端列數; nDelHolders 為受刪除影響之列數; nExternal 為其中來源非空者
+ *   impact     { nRefs, nAnd, nWiden }: nRefs 同 nDelHolders; nAnd 為以 AND 引用者(同清單頁刪除確認框 getDelImpact; targets／users 不適用恆 0); nWiden 為歷史同名只刪其一致授權可能變多者
+ *   similar    [{ from, n }] 與指定 from 去空白忽略大小寫後相同而不相同之來源(僅提示, 不清除)
+ * @example
+ *
+ * let r = planPurgeFrom({ keyTable: 'grups', from: 'pd', tables: {
+ *     users: [{ id: 'u1', cgrups: '{"A":{"mode":"OR","isActive":"y"}}' }],
+ *     grups: [{ id: 'g1', name: 'A', from: 'pd' }],
+ * } })
+ * console.log(r.nRows, r.changes[0].after)
+ * // => 1 {}
+ *
+ */
+function planPurgeFrom(p) {
+    let keyTable = isObj(p) ? p.keyTable : ''
+    let from = isObj(p) ? p.from : undefined
+    let plan = {
+        err: null,
+        keyTable,
+        from,
+        holder: '',
+        field: '',
+        rows: [],
+        delIds: [],
+        nRows: 0,
+        nAdmin: 0,
+        nNoId: 0,
+        changes: [],
+        delNames: [],
+        nHolders: 0,
+        nDelHolders: 0,
+        nExternal: 0,
+        impact: { nRefs: 0, nAnd: 0, nWiden: 0 },
+        similar: [],
+    }
+    if (!TABLE_ORDER.includes(keyTable)) {
+        plan.err = 'invalidTable'
+        return plan
+    }
+    if (!isStr(from) || from === '') {
+        plan.err = 'invalidFrom'
+        return plan
+    }
+    let tables = isObj(p.tables) ? p.tables : {}
+    let rowsOld = arr(tables[keyTable])
+    let isHit = (r) => isObj(r) && r.from === from //精確 ===: from 為非空字串, 故命中者必為外部列
+    let hit = rowsOld.filter(isHit)
+    plan.similar = similarFroms(rowsOld, from)
+    plan.nRows = hit.length
+    plan.nNoId = hit.filter((r) => !hasId(r)).length
+    plan.rows = hit.filter(hasId).map((r) => {
+        let o = { id: r.id }
+        let name = rowName(keyTable, r)
+        if (name !== undefined) {
+            o.name = name
+        }
+        return o
+    })
+    plan.delIds = plan.rows.map((r) => r.id)
+    if (keyTable === 'users') {
+        plan.nAdmin = hit.filter((r) => r.isAdmin === 'y').length
+    }
+    let ref = hasOwn(REF_OF, keyTable) ? REF_OF[keyTable] : null //users 無引用端
+    if (ref !== null) {
+        plan.holder = ref.holder
+        plan.field = ref.field
+    }
+    if (plan.nNoId > 0) {
+        plan.err = 'purgeRowNoId'
+        return plan
+    }
+    if (hit.length === 0 || ref === null) {
+        return plan
+    }
+
+    //引用清理: 與伺服端刪除同一純函數(R-REF-CASCADE-01), rowsNew ＝ 該表扣除被清除列
+    let rowsNew = rowsOld.filter((r) => !isHit(r))
+    let holders = arr(tables[ref.holder])
+    let rp = planRefChanges({ keyTable, rowsOld, rowsNew, holdersOld: holders })
+    if (rp.err !== null) {
+        plan.err = rp.err
+        return plan
+    }
+    plan.changes = rp.changes
+    plan.delNames = rp.delNames
+    plan.nHolders = rp.nHolders
+    plan.nDelHolders = rp.nDelHolders
+    plan.nExternal = rp.nExternal
+    plan.impact.nRefs = rp.nDelHolders
+    if (hasOwn(IMPACT_KIND, keyTable)) {
+        let im = getDelImpact(plan.delIds, rowsOld, holders, IMPACT_KIND[keyTable], rowsNew)
+        plan.impact.nAnd = Math.min(im.nAnd, rp.nDelHolders)
+        plan.impact.nWiden = im.nWiden
+    }
+    return plan
+}
+
+
+/**
+ * 套用清除計畫於四表(回傳新之 tables, 不改輸入; 用於 --table all 之逐表模擬與寫後預測): 移除被清除列、引用端欄位換成 after
+ *
+ * @param {Object} tables 輸入 { users, grups, pemis, targets }
+ * @param {Object} plan 輸入 planPurgeFrom 之結果; err 非 null 者原樣回傳(不套用)
+ * @returns {Object} 回傳新之 tables(僅被改之表為新陣列, 其餘沿用)
+ */
+function applyPurgePlan(tables, plan) {
+    let out = { ...tables }
+    if (!isObj(plan) || plan.err !== null) {
+        return out
+    }
+    let del = new Set(plan.delIds)
+    out[plan.keyTable] = arr(tables[plan.keyTable]).filter((r) => !(isObj(r) && del.has(r.id) && r.from === plan.from))
+    if (plan.holder !== '') {
+        let m = new Map(plan.changes.map((c) => [c.id, c]))
+        out[plan.holder] = arr(tables[plan.holder]).map((r) => {
+            let c = isObj(r) ? m.get(r.id) : undefined
+            return c === undefined ? r : { ...r, [c.field]: c.after }
+        })
+    }
+    return out
+}
+
+
+/**
+ * 規劃多表整來源清除(--table all): 依引用鏈序 targets → pemis → grups → users 逐表規劃, 每表以「前面各表套用後」之模擬狀態計畫(與逐表真實寫入之狀態一致)
+ *
+ * 任一表之計畫有 err 則停止並整體拒絕(err 為該鍵, errTable 為該表; plans 含到失敗表為止之計畫). 純函數, 不改輸入.
+ *
+ * @param {Object} p 輸入參數物件
+ * @param {String} p.from 輸入來源名稱(非空字串, 精確比對)
+ * @param {Object} p.tables 輸入 { users, grups, pemis, targets }
+ * @param {Array} [p.keyTables=TABLE_ORDER] 輸入要清除之表(可為子集; 一律依 TABLE_ORDER 之序處理並去重)
+ * @returns {Object} 回傳 { err, errTable, from, plans, tablesAfter, totals }: tablesAfter 為全部套用後之預測狀態(err 非 null 時無意義);
+ *   totals 為各表加總 { nRows, nHolders, nDelHolders, nAnd, nWiden, nExternal, nAdmin }
+ */
+function planPurgeChain(p) {
+    let from = isObj(p) ? p.from : undefined
+    let tables = isObj(p) && isObj(p.tables) ? p.tables : {}
+    let want = isObj(p) && Array.isArray(p.keyTables) ? p.keyTables : TABLE_ORDER
+    let res = { err: null, errTable: '', from, plans: [], tablesAfter: { ...tables }, totals: { nRows: 0, nHolders: 0, nDelHolders: 0, nAnd: 0, nWiden: 0, nExternal: 0, nAdmin: 0 } }
+    if (!isStr(from) || from === '') {
+        res.err = 'invalidFrom'
+        return res
+    }
+    if (want.length === 0 || want.some((t) => !TABLE_ORDER.includes(t))) {
+        res.err = 'invalidTable'
+        return res
+    }
+    let cur = tables
+    for (let t of TABLE_ORDER.filter((x) => want.includes(x))) {
+        let plan = planPurgeFrom({ keyTable: t, from, tables: cur })
+        res.plans.push(plan)
+        if (plan.err !== null) {
+            res.err = plan.err
+            res.errTable = t
+            return res
+        }
+        res.totals.nRows += plan.nRows
+        res.totals.nHolders += plan.nHolders
+        res.totals.nDelHolders += plan.nDelHolders
+        res.totals.nAnd += plan.impact.nAnd
+        res.totals.nWiden += plan.impact.nWiden
+        res.totals.nExternal += plan.nExternal
+        res.totals.nAdmin += plan.nAdmin
+        cur = applyPurgePlan(cur, plan)
+    }
+    res.tablesAfter = cur
+    return res
+}
+
+
+export { TABLE_ORDER, NON_STRING_KINDS, KIND_ORDER, fromKind, auditFrom, planFixFromType, planPurgeFrom, applyPurgePlan, planPurgeChain }
+export default auditFrom

package/src/js/getAddImpact.mjs

@@ -0,0 +1,197 @@
+import { fmtWarn } from './getAuthWarn.mjs'
+import getEffMode from './getEffMode.mjs'
+import { REF_OF, keyOf, entName, decodeKp, listEntries } from './refCascade.mjs'
+
+
+//清單頁「儲存」前之「新增撞懸空名」確認(F-23／F-26 run07 設計摘要原則 7; 規則帳本 R-PRINCIPLE-00 原則 3「遇衝突或歧義: 收嚴＋提示」、明確同意; 純函數, 不依賴 Vue／DOM／ORM):
+//新增(id 不在基準)之群組／權限／標的, 其名稱(群組／權限為 name, 標的為 id)在基準內查無任何同名實體, 而仍有「啟用中之引用」指向該名稱(懸空引用: 使用者 cgrups、群組 cpemis、權限 crules)——
+//新增後該引用即解到此新實體, 引用端(使用者／群組／權限)之授權隨之變多或受其限制(AND). 後台允許新增, 但須於送出前列出影響並由使用者按「是」才送出.
+//引用之解碼、名稱比對鍵、被引用表與引用端之對應皆沿用 refCascade.mjs(REF_OF／decodeKp／listEntries／entName／keyOf, 與伺服端引用連帶同一套口徑);
+//AND 之判定沿用 getEffMode(mode 缺或非 OR 者視為 AND, 與刪除確認框 countAndRefs 一致); 只有群組／權限之引用項有 mode, 標的之 crules 項目無 mode(mergeRules 之規則只取 isActive), 故標的之 nAnd 恆為 0.
+
+
+//MAX_NAMES: 供顯示之名稱上限(同 getCascadePreview 之 joinList)
+let MAX_NAMES = 5
+
+
+//TEXT_KEY: 頁面種類 → 語系鍵(無 AND 句, 有 AND 句)
+let TEXT_KEY = {
+    Grup: ['confirmAddRefsGrup', 'confirmAddRefsAndGrup'],
+    Pemi: ['confirmAddRefsPemi', 'confirmAddRefsAndPemi'],
+    Target: ['confirmAddRefsTarget', ''],
+}
+
+
+let isStr = (v) => typeof v === 'string'
+let isObj = (v) => v !== null && typeof v === 'object'
+let hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
+
+
+//toId: 列之 id 取字串形式(字串原樣; 有限數字取其字串, 同伺服端寫入前之主鍵正規化), 否則 null(視為無 id: 新列)
+let toId = (r) => {
+    let id = isObj(r) ? r.id : undefined
+    if (isStr(id)) {
+        return id
+    }
+    return (typeof id === 'number' && Number.isFinite(id)) ? String(id) : null
+}
+
+
+//showName: 名稱之顯示形式, 空字串顯示為 "" (否則文案中看不到, 同 getCascadePreview)
+let showName = (v) => (v === '' ? '""' : String(v))
+
+
+/**
+ * 計算「本次新增且撞懸空名」對引用端之影響
+ *
+ * 新增列: rowsNew 中 id 不在 rowsOld 者(缺 id 者亦為新增; 有限數字 id 取字串形式比對). 撞懸空名: 新增列之名稱(群組／權限為 name〔缺欄視為 ''〕, 標的為 id)非字串者不計,
+ * 其比對鍵(群組／權限為字串本身, 標的為屬性鍵轉型)在 rowsOld 內無任何同名實體(歷史同名、本次一併刪除或改名之舊列仍算有同名實體, 其引用之去留由刪除／改名流程確認);
+ * 同一名稱多列新增只計一次. 引用端: holders 中授權字串(cgrups／cpemis／crules)解碼後, 有「isActive 為 'y' 且名稱指向該新名稱」之項目者(停用項目、壞 JSON、空字串、非容器皆不計; 含外部列).
+ * nHolders 為受影響之引用端列數(一列引用多個新名稱只計一次); nAnd 為其中至少有一個此類引用項之有效模式為 AND 者(群組／權限; 標的恆為 0); names 為受影響之新名稱(依 rowsNew 次序、去重、至多 5 個), nNames 為其總數.
+ *
+ * @param {Object} p 輸入參數物件
+ * @param {String} p.keyTable 輸入被新增之表, 'grups'(引用端 users.cgrups)、'pemis'(引用端 grups.cpemis)或 'targets'(引用端 pemis.crules); 其他回傳全 0
+ * @param {Array} p.rowsOld 輸入基準列(store 之該表列, 已儲存者)
+ * @param {Array} p.rowsNew 輸入欲送出之該表整表(清單目前之列; 標的頁為 reuseDeletedIds 正規化後之 rowsSend)
+ * @param {Array} p.holders 輸入引用端表全部列(users／grups／pemis, 含外部列)
+ * @returns {Object} 回傳 { nHolders, nAnd, names, nNames }
+ * @example
+ *
+ * let r = getAddImpact({
+ *     keyTable: 'grups',
+ *     rowsOld: [],
+ *     rowsNew: [{ id: 'g1', name: 'G1' }],
+ *     holders: [{ id: 'u1', cgrups: '{"G1":{"mode":"AND","isActive":"y"}}' }],
+ * })
+ * console.log(r.nHolders, r.nAnd, r.names)
+ * // => 1 1 [ 'G1' ]
+ *
+ */
+function getAddImpact(p) {
+    let res = { nHolders: 0, nAnd: 0, names: [], nNames: 0 }
+    let p0 = isObj(p) ? p : {}
+    let keyTable = p0.keyTable
+    if (!isStr(keyTable) || !hasOwn(REF_OF, keyTable)) {
+        return res
+    }
+    let ref = REF_OF[keyTable]
+    let rowsOld = Array.isArray(p0.rowsOld) ? p0.rowsOld : []
+    let rowsNew = Array.isArray(p0.rowsNew) ? p0.rowsNew : []
+    let holders = Array.isArray(p0.holders) ? p0.holders : []
+
+    //oldIds, keysOld: 基準之字串主鍵集合、基準名稱之比對鍵集合
+    let oldIds = new Set()
+    let keysOld = new Set()
+    rowsOld.forEach((r) => {
+        let id = toId(r)
+        if (id !== null) {
+            oldIds.add(id)
+        }
+        let k = keyOf(entName(r, keyTable), ref.kind)
+        if (k !== null) {
+            keysOld.add(k)
+        }
+    })
+
+    //kpNew: 比對鍵 → 新名稱(新增列且基準無同名實體; Map 依 rowsNew 次序)
+    let kpNew = new Map()
+    rowsNew.forEach((r) => {
+        if (!isObj(r)) {
+            return
+        }
+        let id = toId(r)
+        if (id !== null && oldIds.has(id)) {
+            return //既有列(含改名), 非新增
+        }
+        let name = entName(r, keyTable)
+        let k = keyOf(name, ref.kind)
+        if (k === null || keysOld.has(k) || kpNew.has(k)) {
+            return
+        }
+        kpNew.set(k, name)
+    })
+    if (kpNew.size === 0) {
+        return res
+    }
+
+    //holders: 解碼各引用端之授權字串, 找啟用中且指向新名稱之項目
+    let kpHit = new Set() //受影響之比對鍵
+    holders.forEach((h) => {
+        if (!isObj(h)) {
+            return
+        }
+        let kp = decodeKp(h[ref.field])
+        if (kp === null) {
+            return
+        }
+        let isHit = false
+        let isAnd = false
+        listEntries(kp, ref.kind).forEach((e) => {
+            if (e.key === null || !kpNew.has(e.key) || e.isActive !== 'y') {
+                return
+            }
+            isHit = true
+            kpHit.add(e.key)
+            if (ref.kind === 'ref') {
+                let mode = (e.isObj && hasOwn(e.el, 'mode')) ? e.el.mode : undefined
+                if (getEffMode(mode) === 'AND') {
+                    isAnd = true
+                }
+            }
+        })
+        if (isHit) {
+            res.nHolders++
+        }
+        if (isAnd) {
+            res.nAnd++
+        }
+    })
+
+    //names: 受影響之新名稱(依 rowsNew 次序)
+    let names = []
+    kpNew.forEach((name, k) => {
+        if (kpHit.has(k)) {
+            names.push(name)
+        }
+    })
+    res.nNames = names.length
+    res.names = names.slice(0, MAX_NAMES)
+
+    return res
+}
+
+
+/**
+ * 新增撞懸空名之確認框文字: nHolders 為 0 回空字串(不彈框); 有 AND 引用者(群組／權限頁)選含 AND 句之語系鍵
+ *
+ * 文案依頁面種類選鍵: 'Grup'(群組頁, 引用端為使用者) confirmAddRefsGrup／confirmAddRefsAndGrup; 'Pemi'(權限頁, 引用端為群組) confirmAddRefsPemi／confirmAddRefsAndPemi;
+ * 'Target'(標的頁, 引用端為權限) confirmAddRefsTarget(無 AND 句). 佔位符: {list} 為新名稱清單(至多 5 個, 超過附 cascadeListMore 之總數), {n} 為受影響之引用端數, {m} 為其中以 AND 引用者.
+ * 單一框、單一問句(「確定新增？」). 種類不明回空字串.
+ *
+ * @param {Object} impact 輸入 getAddImpact 之結果 { nHolders, nAnd, names, nNames }
+ * @param {Function} $t 輸入語系函數(key → 文字)
+ * @param {String} kind 輸入頁面種類: 'Grup'、'Pemi' 或 'Target'
+ * @returns {String} 回傳確認框文字, 無影響為空字串
+ */
+function getAddConfirmText(impact, $t, kind) {
+    if (!isStr(kind) || !hasOwn(TEXT_KEY, kind)) {
+        return ''
+    }
+    let n = (isObj(impact) && impact.nHolders > 0) ? impact.nHolders : 0
+    if (n === 0) {
+        return ''
+    }
+    let m = (impact.nAnd > 0 && TEXT_KEY[kind][1] !== '') ? Math.min(impact.nAnd, n) : 0
+    let key = TEXT_KEY[kind][m > 0 ? 1 : 0]
+    let names = Array.isArray(impact.names) ? impact.names : []
+    let nNames = impact.nNames > names.length ? impact.nNames : names.length
+    let list = names.map(showName).join(', ')
+    if (nNames > names.length) {
+        list = `${list} ${fmtWarn($t('cascadeListMore'), { n: nNames })}`
+    }
+    return fmtWarn($t(key), { n, m, list })
+}
+
+
+export { getAddImpact, getAddConfirmText }
+export default getAddImpact