@aiquants/resize-panels 2.0.0 → 2.0.1

package/src/reducer.ts

@@ -1,472 +0,0 @@
-/**
- * @file Panel group reducer: the only writer of panel sizes.
- * パネルグループのリデューサー: パネルサイズを書き込む唯一の主体。
- *
- * Every action edits configuration or preferences and then runs the same allocator, so the first paint, a
- * container resize, a drag, a collapse and a restored layout all produce sizes from one function of
- * (preferences, constraints, container length).
- * すべてのアクションは構成か希望値を編集したうえで同一の配分器を実行する。したがって初回描画・コンテナリサイズ・
- * ドラッグ・折りたたみ・レイアウト復元のいずれも、(希望値, 制約, コンテナ長) の同一関数からサイズを得る。
- */
-
-import { allocatePanelSizes, isPixelPanel, resolvePanelBounds } from "./allocateLayout"
-import { type LayoutConstraintViolation, PANEL_ALLOCATION_EPSILON, type PanelAction, type PanelCollapseDirection, type PanelGroupLayoutState, type PanelLayoutData, type PanelRegistration } from "./types"
-import { calculateSnapThreshold, clamp } from "./utils"
-import { Logger, LogLevel } from "./utils/simple-logger"
-
-const logger = new Logger(LogLevel.INFO, "[resize-panels]")
-
-/**
- * Empty layout state used before the group has measured itself or registered any panel.
- * グループが自身を計測する前・パネル登録前の空レイアウト状態。
- */
-export const initialPanelGroupLayoutState: PanelGroupLayoutState = {
-    containerSize: 0,
-    panels: [],
-    violation: null,
-}
-
-/**
- * Report whether two violations describe the same situation.
- * 2 つの違反が同じ状況を表すかどうかの判定。
- */
-const isSameViolation = (left: LayoutConstraintViolation | null, right: LayoutConstraintViolation | null): boolean => {
-    if (left === null || right === null) {
-        return left === right
-    }
-    return (
-        left.reason === right.reason &&
-        Math.abs(left.totalMinimumSize - right.totalMinimumSize) <= PANEL_ALLOCATION_EPSILON &&
-        Math.abs(left.totalMaximumSize - right.totalMaximumSize) <= PANEL_ALLOCATION_EPSILON &&
-        Math.abs(left.availableContainerSize - right.availableContainerSize) <= PANEL_ALLOCATION_EPSILON
-    )
-}
-
-/**
- * Run the allocator over the given panels and fold the result into a layout state.
- * 与えられたパネルへ配分器を実行し、結果をレイアウト状態へ畳み込む処理。
- *
- * Panel objects and the panel array keep their identity when the allocation did not move them, so a transition
- * that changes nothing produces no new state and no render at all. (When something does change, every panel of
- * the group re-renders: they all read the same context value.)
- * 配分でサイズが動かなかったパネルとパネル配列は同一性を保つため、何も変えない遷移は新しい状態を作らず再描画も
- * 起こらない (何かが変われば、同じコンテキスト値を読むグループ内の全パネルが再描画される)。
- *
- * @param panels - Panels in DOM order with up-to-date preferences / 希望値が最新の DOM 順パネル一覧
- * @param containerSize - Container content-box length in pixels / コンテナ内容領域長 (px)
- * @returns Layout state whose sizes satisfy the allocator / 配分結果を反映したレイアウト状態
- */
-const allocate = (panels: PanelLayoutData[], containerSize: number): PanelGroupLayoutState => {
-    const { sizes, violation } = allocatePanelSizes(panels, containerSize)
-
-    let changed = false
-    const nextPanels = panels.map((panel, index) => {
-        const size = panel.collapsed ? 0 : sizes[index]
-        if (Math.abs(panel.size - size) <= PANEL_ALLOCATION_EPSILON) {
-            return panel
-        }
-        changed = true
-        return { ...panel, size }
-    })
-
-    const next = { containerSize, panels: changed ? nextPanels : panels, violation }
-    reportInvariantBreach(next)
-    return next
-}
-
-/**
- * Find the layout invariant breach in a state, if there is one.
- * レイアウト状態に不変条件の違反があれば、その内容を返す処理。
- *
- * The condition is the one the whole package rests on: with a measured container and no reported constraint
- * conflict, the active panels fill it exactly. The misaligned handle this package once shipped was a silent
- * violation of exactly this — the sizes stopped filling the container and nothing noticed.
- * ここで見る条件はパッケージ全体の土台である: コンテナが計測済みで制約矛盾も報告されていないなら、
- * アクティブなパネルはコンテナをちょうど満たす。かつて出荷された「ハンドルがずれる」欠陥は、まさにこの条件が
- * 無言で破れた状態だった。
- *
- * @param state - Layout state to check / 検査するレイアウト状態
- * @returns Allocated total and container length when they disagree, otherwise null / 食い違う場合の合計と
- *   コンテナ長、問題なければ null
- */
-export const findLayoutInvariantBreach = (state: PanelGroupLayoutState): { allocatedTotal: number; containerSize: number } | null => {
-    if (state.containerSize <= 0 || state.violation !== null) {
-        return null
-    }
-    let total = 0
-    let activeCount = 0
-    for (const panel of state.panels) {
-        if (!panel.collapsed) {
-            total += panel.size
-            activeCount += 1
-        }
-    }
-    // 全パネルが折りたたまれたグループは「満たすべきパネルが無い」正当な状態
-    if (activeCount === 0) {
-        return null
-    }
-    const tolerance = PANEL_ALLOCATION_EPSILON * Math.max(1, state.containerSize)
-    if (!Number.isFinite(total) || Math.abs(total - state.containerSize) > tolerance) {
-        return { allocatedTotal: total, containerSize: state.containerSize }
-    }
-    return null
-}
-
-/**
- * Report a layout invariant breach, which can only come from a defect in this package.
- * レイアウト不変条件の違反を報告する処理 (違反はこのパッケージの欠陥でしか起こり得ない)。
- *
- * The check is O(panels) with no allocation, so it runs on every transition rather than behind a flag.
- * 検査はパネル数に比例するだけで確保も伴わないため、フラグに隠さずすべての遷移で実行する。
- *
- * @param state - Layout state produced by the allocator / 配分器が生成したレイアウト状態
- */
-const reportInvariantBreach = (state: PanelGroupLayoutState): void => {
-    const breach = findLayoutInvariantBreach(state)
-    if (breach) {
-        logger.error("Allocated sizes do not fill the container.", {
-            ...breach,
-            panels: state.panels.map((panel) => ({ id: panel.id, size: panel.size, collapsed: panel.collapsed })),
-        })
-    }
-}
-
-/**
- * Fold a freshly allocated state into the previous one, preserving identity where nothing moved.
- * 新たに配分した状態を直前の状態へ畳み込み、変化が無い部分の同一性を保つ処理。
- */
-const commit = (previous: PanelGroupLayoutState, next: PanelGroupLayoutState): PanelGroupLayoutState => {
-    if (previous.panels === next.panels && previous.containerSize === next.containerSize && isSameViolation(previous.violation, next.violation)) {
-        return previous
-    }
-    return {
-        containerSize: next.containerSize,
-        panels: next.panels,
-        violation: isSameViolation(previous.violation, next.violation) ? previous.violation : next.violation,
-    }
-}
-
-/**
- * Create the layout data of a newly registered panel.
- * 新規登録パネルのレイアウトデータを生成する処理。
- */
-const createPanel = (registration: PanelRegistration, defaultCollapsedFrom: PanelCollapseDirection | null): PanelLayoutData => {
-    const preference = registration.sizeUnit === "pixels" ? registration.preferredPixelSize : registration.preferredPercentageSize
-    return {
-        ...registration,
-        size: 0,
-        collapsed: registration.collapsed,
-        collapsedByDirection: registration.collapsed ? defaultCollapsedFrom : null,
-        preferenceBeforeCollapse: preference,
-        authoredPreference: preference,
-    }
-}
-
-/**
- * Resolve the direction a panel collapses to when it starts collapsed.
- * 初期状態で折りたたまれているパネルの折りたたみ方向を解決する処理。
- */
-const initialCollapseDirection = (registration: Pick<PanelRegistration, "collapseFromStart" | "collapseFromEnd">): PanelCollapseDirection | null => {
-    if (registration.collapseFromStart) {
-        return "start"
-    }
-    if (registration.collapseFromEnd) {
-        return "end"
-    }
-    return null
-}
-
-/**
- * Rewrite every active panel's preference so that it reproduces the sizes it currently has.
- * アクティブな各パネルの希望値を、現在のサイズを再現する値へ書き換える処理。
- *
- * A drag is a statement about proportions, so the sizes it produced become the new preferences. Because a
- * flexible panel's weight is then exactly `size / C × 100`, re-running the allocator returns the very same
- * sizes: the layout the user released the pointer on is a fixed point.
- * ドラッグは比率に対する利用者の意思表示なので、その結果のサイズを新たな希望値とする。柔軟パネルの重みは
- * `size / C × 100` そのものになるため、配分器を再実行しても同じサイズが返る (ドラッグ結果は不動点)。
- */
-const commitPreferences = (panels: PanelLayoutData[], containerSize: number): PanelLayoutData[] => {
-    if (containerSize <= 0) {
-        return panels
-    }
-    // 端まで引いて折りたたむ操作では、閉じる直前のフレームの寸法が復元用に残ると
-    // 展開しても潰れたままになる。復元用の希望値は「閉じたとみなす幅より広い間」だけ更新する
-    const snapThreshold = calculateSnapThreshold(containerSize)
-    return panels.map((panel) => {
-        if (panel.collapsed) {
-            return panel
-        }
-        const preference = isPixelPanel(panel) ? panel.size : (panel.size / containerSize) * 100
-        const current = isPixelPanel(panel) ? panel.preferredPixelSize : panel.preferredPercentageSize
-        const preferenceBeforeCollapse = panel.size > snapThreshold ? preference : panel.preferenceBeforeCollapse
-        if (current === preference && preferenceBeforeCollapse === panel.preferenceBeforeCollapse) {
-            return panel
-        }
-        return isPixelPanel(panel) ? { ...panel, preferredPixelSize: preference, preferenceBeforeCollapse } : { ...panel, preferredPercentageSize: preference, preferenceBeforeCollapse }
-    })
-}
-
-/**
- * Set a panel's preference from an absolute pixel length.
- * 絶対ピクセル長からパネルの希望値を設定する処理。
- *
- * A flexible panel's weight is a share of the container, so an absolute length only lands where it was
- * asked for when the active panels' weights are expressed on the same scale — which is why every caller
- * that hands out absolute lengths rewrites the whole set.
- * 柔軟パネルの重みはコンテナ比なので、絶対長がそのままの位置に収まるのはアクティブパネルの重みが同じ尺度で
- * 表されているときだけである。絶対長を配る呼び出し側が常に集合全体を書き換えるのはこのため。
- */
-const withPreferenceFromPixels = (panel: PanelLayoutData, pixels: number, containerSize: number): PanelLayoutData => {
-    if (isPixelPanel(panel)) {
-        const preferredPixelSize = Math.max(0, pixels)
-        return { ...panel, preferredPixelSize, preferenceBeforeCollapse: preferredPixelSize }
-    }
-    if (containerSize <= 0) {
-        return panel
-    }
-    const preferredPercentageSize = Math.max(0, (pixels / containerSize) * 100)
-    return { ...panel, preferredPercentageSize, preferenceBeforeCollapse: preferredPercentageSize }
-}
-
-/**
- * Express a panel's preference as a length in pixels for the given container.
- * パネルの希望値を、指定コンテナに対するピクセル長として表す処理。
- *
- * This is the length the panel occupies when it is open, which is what a persisted layout has to carry: the
- * allocated size of a collapsed panel is 0 and would restore as "closed and with nothing to open to".
- * これは「開いているときに占める長さ」であり、保存レイアウトが持つべき値でもある。折りたたみ中のパネルの
- * 配分結果は 0 であり、そのまま保存すると「閉じたまま、開く先も無い」状態として復元されてしまう。
- *
- * @param panel - Panel layout data / パネルレイアウトデータ
- * @param containerSize - Container content-box length in pixels / コンテナ内容領域長 (px)
- * @returns Preferred length in pixels / 希望する長さ (px)
- */
-export const getPanelPreferenceInPixels = (panel: PanelLayoutData, containerSize: number): number => {
-    const preference = panel.collapsed ? panel.preferenceBeforeCollapse : isPixelPanel(panel) ? panel.preferredPixelSize : panel.preferredPercentageSize
-    return isPixelPanel(panel) ? preference : (preference / 100) * containerSize
-}
-
-/**
- * Give one panel an absolute length and let the other active panels share what is left, keeping their ratio.
- * 1 枚のパネルへ絶対長を与え、残りのアクティブパネルが現在の比のまま残余を分け合うよう希望値を揃える処理。
- *
- * @param panels - Panels in DOM order / DOM 順のパネル一覧
- * @param targetId - Panel that receives the absolute length / 絶対長を受け取るパネル
- * @param pixels - Absolute length in pixels / 絶対長 (px)
- * @param containerSize - Container content-box length in pixels / コンテナ内容領域長 (px)
- * @returns Panels whose preferences reproduce the requested layout / 要求どおりの配置を再現する希望値を持つパネル一覧
- */
-const withAbsoluteSize = (panels: PanelLayoutData[], targetId: string, pixels: number, containerSize: number): PanelLayoutData[] => {
-    const target = Math.max(0, Math.min(pixels, containerSize))
-    // ピクセルパネルの希望長は利用者が宣言した絶対値なので、他のパネルの都合で書き換えない。
-    // 残余を分け合うのは柔軟パネルだけ
-    const sharing = panels.filter((panel) => panel.id !== targetId && !panel.collapsed && !isPixelPanel(panel))
-    const reserved = panels.reduce((total, panel) => (panel.id !== targetId && !panel.collapsed && isPixelPanel(panel) ? total + panel.size : total), 0)
-    const sharingTotal = sharing.reduce((total, panel) => total + panel.size, 0)
-    const sharingBudget = Math.max(0, containerSize - target - reserved)
-
-    return panels.map((panel) => {
-        if (panel.id === targetId) {
-            return withPreferenceFromPixels(panel, target, containerSize)
-        }
-        if (panel.collapsed || isPixelPanel(panel) || sharing.length === 0) {
-            return panel
-        }
-        const share = sharingTotal > 0 ? (panel.size / sharingTotal) * sharingBudget : sharingBudget / sharing.length
-        return withPreferenceFromPixels(panel, share, containerSize)
-    })
-}
-
-/**
- * Reduce the layout state of one panel group.
- * パネルグループのレイアウト状態を遷移させるリデューサー。
- *
- * @param state - Current layout state / 現在のレイアウト状態
- * @param action - Action describing the edit / 編集内容を表すアクション
- * @returns Next layout state, identical by reference when nothing changed / 次のレイアウト状態 (無変化なら同一参照)
- */
-export const panelReducer = (state: PanelGroupLayoutState, action: PanelAction): PanelGroupLayoutState => {
-    switch (action.type) {
-        case "SET_CONTAINER_SIZE": {
-            if (!Number.isFinite(action.containerSize) || action.containerSize < 0 || action.containerSize === state.containerSize) {
-                return state
-            }
-            return commit(state, allocate(state.panels, action.containerSize))
-        }
-
-        case "REGISTER_PANEL": {
-            const index = state.panels.findIndex((panel) => panel.id === action.panel.id)
-            if (index === -1) {
-                const panels = [...state.panels, createPanel(action.panel, initialCollapseDirection(action.panel))]
-                return commit(state, allocate(panels, state.containerSize))
-            }
-
-            const previous = state.panels[index]
-            const authored = action.panel.sizeUnit === "pixels" ? action.panel.preferredPixelSize : action.panel.preferredPercentageSize
-            // 利用者が指定した既定サイズが変わったときだけ希望値を採用する。
-            // 変わっていない再登録 (制約プロパティの変更など) でドラッグ結果を巻き戻さないための判定
-            const adoptsAuthoredPreference = authored !== previous.authoredPreference || action.panel.sizeUnit !== previous.sizeUnit
-            const collapseDirectionStillAllowed = previous.collapsedByDirection === "start" ? action.panel.collapseFromStart : previous.collapsedByDirection === "end" ? action.panel.collapseFromEnd : false
-            // 折りたたみ設定が変わったのに方向が残ると、どの方向でも展開できないパネルになる
-            const stillCollapsible = action.panel.collapseFromStart || action.panel.collapseFromEnd
-            const nextCollapsed = previous.collapsed && stillCollapsible
-            const updated: PanelLayoutData = {
-                ...previous,
-                ...action.panel,
-                collapsed: nextCollapsed,
-                collapsedByDirection: nextCollapsed ? (collapseDirectionStillAllowed ? previous.collapsedByDirection : initialCollapseDirection(action.panel)) : null,
-                preferredPercentageSize: adoptsAuthoredPreference ? action.panel.preferredPercentageSize : previous.preferredPercentageSize,
-                preferredPixelSize: adoptsAuthoredPreference ? action.panel.preferredPixelSize : previous.preferredPixelSize,
-                preferenceBeforeCollapse: adoptsAuthoredPreference ? authored : previous.preferenceBeforeCollapse,
-                authoredPreference: authored,
-            }
-
-            const panels = [...state.panels]
-            panels[index] = updated
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        case "UNREGISTER_PANEL": {
-            const panels = state.panels.filter((panel) => panel.id !== action.id)
-            if (panels.length === state.panels.length) {
-                return state
-            }
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        case "REORDER_PANELS": {
-            if (action.ids.length !== state.panels.length) {
-                // DOM と登録状態が一時的にずれている間は並べ替えない (揃った時点で再度通知される)
-                return state
-            }
-            if (new Set(action.ids).size !== action.ids.length) {
-                // 同じ id が 2 度現れる並びは、片方のパネルを取り違えて落とすことになる
-                return state
-            }
-            const byId = new Map(state.panels.map((panel) => [panel.id, panel]))
-            const panels: PanelLayoutData[] = []
-            for (const id of action.ids) {
-                const panel = byId.get(id)
-                if (!panel) {
-                    return state
-                }
-                panels.push(panel)
-            }
-            if (panels.every((panel, index) => panel === state.panels[index])) {
-                return state
-            }
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        case "RESIZE_PANELS": {
-            const startIndex = state.panels.findIndex((panel) => panel.id === action.startId)
-            const endIndex = state.panels.findIndex((panel) => panel.id === action.endId)
-            if (startIndex === -1 || endIndex === -1) {
-                return state
-            }
-
-            const startPanel = state.panels[startIndex]
-            const endPanel = state.panels[endIndex]
-            if (startPanel.collapsed || endPanel.collapsed || state.containerSize <= 0 || !Number.isFinite(action.startSize)) {
-                return state
-            }
-
-            // ドラッグはこの 2 枚の間で領域を移すだけの操作なので、合計は動かさない
-            const total = startPanel.size + endPanel.size
-            const startBounds = resolvePanelBounds(startPanel, state.containerSize)
-            const endBounds = resolvePanelBounds(endPanel, state.containerSize)
-            const lowerBound = Math.max(startBounds.min, total - endBounds.max)
-            const upperBound = Math.min(startBounds.max, total - endBounds.min)
-            if (lowerBound - upperBound > PANEL_ALLOCATION_EPSILON) {
-                return state
-            }
-
-            const startSize = clamp(action.startSize, lowerBound, Math.max(lowerBound, upperBound))
-            const endSize = total - startSize
-            if (Math.abs(startSize - startPanel.size) <= PANEL_ALLOCATION_EPSILON) {
-                return state
-            }
-
-            const resized = [...state.panels]
-            resized[startIndex] = { ...startPanel, size: startSize }
-            resized[endIndex] = { ...endPanel, size: endSize }
-            return commit(state, allocate(commitPreferences(resized, state.containerSize), state.containerSize))
-        }
-
-        case "COLLAPSE_PANEL": {
-            const index = state.panels.findIndex((panel) => panel.id === action.id)
-            if (index === -1) {
-                return state
-            }
-            const panel = state.panels[index]
-            const allowed = action.from === "start" ? panel.collapseFromStart : panel.collapseFromEnd
-            if (!allowed || panel.collapsed) {
-                return state
-            }
-
-            const panels = [...state.panels]
-            panels[index] = {
-                ...panel,
-                collapsed: true,
-                collapsedByDirection: action.from,
-            }
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        case "EXPAND_PANEL": {
-            const index = state.panels.findIndex((panel) => panel.id === action.id)
-            if (index === -1 || (action.targetSize !== undefined && state.containerSize <= 0)) {
-                return state
-            }
-            const panel = state.panels[index]
-            const allowed = action.from === "start" ? panel.collapseFromStart : panel.collapseFromEnd
-            if (!(allowed && panel.collapsed) || (panel.collapsedByDirection !== null && panel.collapsedByDirection !== action.from)) {
-                return state
-            }
-
-            const restored: PanelLayoutData = {
-                ...panel,
-                collapsed: false,
-                collapsedByDirection: null,
-                preferredPixelSize: isPixelPanel(panel) ? panel.preferenceBeforeCollapse : panel.preferredPixelSize,
-                preferredPercentageSize: isPixelPanel(panel) ? panel.preferredPercentageSize : panel.preferenceBeforeCollapse,
-            }
-
-            const expanded = [...state.panels]
-            expanded[index] = restored
-            const panels = action.targetSize === undefined ? expanded : withAbsoluteSize(expanded, action.id, action.targetSize, state.containerSize)
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        case "RESTORE_LAYOUT": {
-            if (action.entries.length !== state.panels.length || state.containerSize <= 0) {
-                return state
-            }
-            const stored = new Map(action.entries.map((entry) => [entry.id, entry]))
-            if (state.panels.some((panel) => !stored.has(panel.id))) {
-                // 保存時と構成が違う。位置で当てはめると別のパネルへ他人の寸法を与えてしまうため適用しない
-                return state
-            }
-            const panels = state.panels.map((panel) => {
-                const entry = stored.get(panel.id)
-                if (!entry) {
-                    return panel
-                }
-                // 保存されているのは「開いているときに占める長さ」なので、折りたたみ状態に関わらず希望値として適用する
-                const restored = withPreferenceFromPixels(panel, entry.size, state.containerSize)
-                const canCollapse = panel.collapseFromStart || panel.collapseFromEnd
-                if (entry.collapsed && canCollapse) {
-                    return { ...restored, collapsed: true, collapsedByDirection: panel.collapsedByDirection ?? initialCollapseDirection(panel) }
-                }
-                return restored.collapsed ? { ...restored, collapsed: false, collapsedByDirection: null } : restored
-            })
-            logger.debug("restore layout", { containerSize: state.containerSize, entries: action.entries })
-            return commit(state, allocate(panels, state.containerSize))
-        }
-
-        default: {
-            return state
-        }
-    }
-}

package/src/roundHalfToEven.ts

@@ -1,40 +0,0 @@
-/**
- * Round a number to specified digits using banker's rounding (round half to even).
- * 指定した桁で銀行丸め (最近接偶数への丸め) を行う関数。
- *
- * @param value - 丸め対象の数値
- * @param digits - 丸める桁数 (0: 整数, 1: 小数第1位, -1: 十の位)
- * @returns 丸められた数値
- */
-export const roundHalfToEven = (value: number, digits: number = 0): number => {
-    // 非有限値はそのまま返す
-    if (!Number.isFinite(value)) {
-        return value
-    }
-
-    // 桁を移動させるための乗数を計算
-    const multiplier = 10 ** digits
-    const shifted = value * multiplier
-
-    // 整数部分と小数部分を分離
-    const floor = Math.floor(shifted)
-    const fraction = shifted - floor
-
-    // 浮動小数点誤差を考慮したイプシロン値
-    const epsilon = Number.EPSILON * Math.max(1, Math.abs(shifted))
-
-    // 0.5 未満の場合は切り捨て
-    if (fraction < 0.5 - epsilon) {
-        return floor / multiplier
-    }
-
-    // 0.5 より大きい場合は切り上げ
-    if (fraction > 0.5 + epsilon) {
-        return (floor + 1) / multiplier
-    }
-
-    // ちょうど 0.5 の場合は、最近接偶数に丸める
-    // floor が偶数なら floor、奇数なら floor + 1
-    const rounded = floor % 2 === 0 ? floor : floor + 1
-    return rounded / multiplier
-}

package/src/styles/components.entry.css

@@ -1,10 +0,0 @@
-/*
- * Artifact A: components-only CSS (Tailwind ホスト向け).
- * 手書きコンポーネントクラスのみ (resize-panels は大半のスタイルを JSX ユーティリティで持つため
- * この成果物はほぼ空になる)。preflight・:root テーマ変数・ユーティリティは含まない
- * (preflight を Tailwind ホストへ流し込むとホストの base 層を破壊するため厳禁)。
- */
-@import "tailwindcss/theme.css" theme(reference);
-@layer components {
-  @import "./resize-panels.css";
-}

package/src/styles/resize-panels.css

@@ -1 +0,0 @@
-/* nothing */

package/src/styles/standalone.entry.css

@@ -1,12 +0,0 @@
-/*! @aiquants/resize-panels standalone CSS — 非 Tailwind ホスト専用。ホストの Tailwind ビルドと混在させないこと */
-/*
- * Artifact B: 自己完結スタンドアロン. 非 Tailwind ホストの利便のため preflight を同梱する
- * (Tailwind ホストはホスト自身の preflight があるので Artifact A を使うこと)。
- */
-@layer theme, base, components, utilities;
-@import "tailwindcss/theme.css" layer(theme);
-@import "tailwindcss/preflight.css" layer(base);
-@import "tailwindcss/utilities.css" layer(utilities) source(none);
-@import "./resize-panels.css" layer(components);
-@source "../**/*.{ts,tsx}";
-@custom-variant dark (&:where(.dark, .dark *));