@lark-apaas/coding-steering 0.1.32-dev.6f4e4bc → 0.1.32-dev.88fb097

package/steering/design-html/skills/pptx-style-extract/scripts/verify_layout_assets.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """Verify that generated slides honor every asset bound to their PPTX layout."""
 import argparse
+import hashlib
+import os
 import posixpath
 import re
 import sys
@@ -40,14 +42,12 @@ def bound_asset_ids(value, known_asset_ids):
 
 def layout_asset_contract(pack):
     known_asset_ids = set(pack.assets)
-    required = {}
     owners = {}
     for layout_name, (layout, _) in pack.layouts.items():
-        asset_counts = bound_asset_ids(layout, known_asset_ids)
-        required[layout_name] = asset_counts
-        for asset_id in asset_counts:
+        for asset_id, _, _ in layout_asset_instances(
+                layout, known_asset_ids, pack.canvas):
             owners.setdefault(asset_id, set()).add(layout_name)
-    return required, owners
+    return owners
 
 
 def asset_urls(pack, asset_prefix, asset_ids):
@@ -63,10 +63,118 @@ def asset_urls(pack, asset_prefix, asset_ids):
         relative = normalized_path(path)
         if relative.startswith('assets/'):
             relative = relative[len('assets/'):]
-        urls[posixpath.join(prefix, relative)] = asset_id
+        urls.setdefault(posixpath.join(prefix, relative), set()).add(asset_id)
     return urls
 
 
+def bound_asset_instances(value, known_asset_ids):
+    """Return every positioned fixed-asset instance nested in slots or flow."""
+    instances = []
+    if isinstance(value, dict):
+        box = value.get('box')
+        asset_id = value.get('asset')
+        if (isinstance(box, list) and len(box) == 4
+                and isinstance(asset_id, str)
+                and asset_id in known_asset_ids):
+            instances.append((asset_id, value.get('role') or 'asset', box))
+        for key, child in value.items():
+            if key not in ('asset', 'background'):
+                instances.extend(bound_asset_instances(child, known_asset_ids))
+    elif isinstance(value, list):
+        for child in value:
+            instances.extend(bound_asset_instances(child, known_asset_ids))
+    return instances
+
+
+def layout_asset_instances(layout, known_asset_ids, canvas):
+    """Return every fixed image instance declared by one layout."""
+    if not isinstance(layout, dict):
+        return []
+    instances = []
+    background = layout.get('background')
+    if canvas and isinstance(background, str) and background in known_asset_ids:
+        instances.append(
+            (background, 'background', [0, 0, canvas[0], canvas[1]]))
+    instances.extend(bound_asset_instances(layout, known_asset_ids))
+    return instances
+
+
+def inline_styles(value):
+    styles = {}
+    for declaration in (value or '').split(';'):
+        if ':' not in declaration:
+            continue
+        name, raw = declaration.split(':', 1)
+        styles[name.strip().lower()] = re.sub(
+            r'\s*!important\s*$', '', raw.strip().lower())
+    return styles
+
+
+def css_number(value):
+    match = re.fullmatch(r'(-?(?:\d+(?:\.\d*)?|\.\d+))(?:px)?', value or '')
+    return float(match.group(1)) if match else None
+
+
+def element_box(reference, canvas):
+    styles = reference['styles']
+    if reference['slide_root'] and not any(
+            name in styles for name in ('left', 'top', 'width', 'height')):
+        return [0.0, 0.0, float(canvas[0]), float(canvas[1])]
+    values = [
+        css_number(styles.get(name))
+        for name in ('left', 'top', 'width', 'height')
+    ]
+    if styles.get('position') != 'absolute' or any(
+            value is None for value in values):
+        return None
+    return values
+
+
+def boxes_match(actual, expected, tolerance=1.0):
+    return actual is not None and all(
+        abs(actual_value - expected_value) <= tolerance
+        for actual_value, expected_value in zip(actual, expected)
+    )
+
+
+def file_sha256(path):
+    digest = hashlib.sha256()
+    with open(path, 'rb') as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def copied_asset_problems(pack, html_path, asset_prefix, asset_ids):
+    """Verify copied fixed assets still contain the source PPTX bytes."""
+    problems = []
+    html_root = os.path.dirname(os.path.abspath(html_path))
+    prefix = normalized_path(asset_prefix).rstrip('/')
+    for asset_id in sorted(asset_ids):
+        entry, _ = pack.assets.get(asset_id, (None, None))
+        path = entry.get('path') if isinstance(entry, dict) else None
+        if not isinstance(path, str) or not path:
+            continue
+        relative = normalized_path(path)
+        if relative.startswith('assets/'):
+            relative = relative[len('assets/'):]
+        source_path = os.path.join(pack.root, 'assets', *relative.split('/'))
+        copied_relative = posixpath.join(prefix, relative)
+        copied_path = os.path.join(html_root, *copied_relative.split('/'))
+        if not os.path.isfile(copied_path):
+            problems.append(
+                '固定素材 %s 未复制到项目: %s' % (asset_id, copied_relative))
+            continue
+        if not os.path.isfile(source_path):
+            problems.append(
+                '风格包中的固定素材 %s 不存在: %s' % (asset_id, path))
+            continue
+        if file_sha256(copied_path) != file_sha256(source_path):
+            problems.append(
+                '固定素材 %s 已被替换或改写，必须使用 PPTX 原文件' % asset_id)
+    return problems
+
+
 def urls_from_attrs(attrs):
     urls = []
     for key, value in attrs:
@@ -85,50 +193,72 @@ class SlideAssetParser(HTMLParser):
     def __init__(self):
         super().__init__()
         self.slides = []
-        self._tags = []
-        self._sections = []
-        self._active_slides = []
+        self._stack = []
         self._style_depth = 0
         self.outside_urls = []
 
     def handle_starttag(self, tag, attrs):
         tag = tag.lower()
+        attrs_map = {key.lower(): value for key, value in attrs}
         urls = urls_from_attrs(attrs)
-        parent = self._tags[-1] if self._tags else None
-        if tag == 'section':
-            slide = (
-                {'layout': dict(attrs).get('data-pptx-layout'), 'urls': urls}
-                if parent == 'deck-stage' else None
+        parent = self._stack[-1] if self._stack else None
+        parent_slide = parent['slide'] if parent else None
+        slide_root = bool(
+            tag == 'section' and parent and parent['tag'] == 'deck-stage')
+        slide = ({
+            'layout': attrs_map.get('data-pptx-layout'),
+            'theme': attrs_map.get('data-pptx-theme'),
+            'references': [],
+        } if slide_root else parent_slide)
+        if slide_root:
+            self.slides.append(slide)
+        styles = inline_styles(attrs_map.get('style'))
+        hidden = bool(
+            (parent and parent['hidden'])
+            or 'hidden' in attrs_map
+            or attrs_map.get('aria-hidden', '').lower() == 'true'
+            or styles.get('display') == 'none'
+            or styles.get('visibility') in ('hidden', 'collapse')
+            or styles.get('content-visibility') == 'hidden'
+            or css_number(styles.get('width')) == 0
+            or css_number(styles.get('height')) == 0
+            or (
+                css_number(styles.get('opacity')) is not None
+                and css_number(styles.get('opacity')) <= 0
             )
-            self._sections.append(slide)
-            if slide is not None:
-                self._active_slides.append(slide)
-        elif self._active_slides:
-            self._active_slides[-1]['urls'].extend(urls)
-        else:
+        )
+        if slide is not None and (urls or attrs_map.get('data-pptx-asset')):
+            slide['references'].append({
+                'asset': attrs_map.get('data-pptx-asset'),
+                'hidden': hidden,
+                'slide_root': slide_root,
+                'source': attrs_map.get('src'),
+                'styles': styles,
+                'tag': tag,
+                'urls': urls,
+            })
+        elif urls:
             self.outside_urls.extend(urls)
         if tag == 'style':
             self._style_depth += 1
         if tag not in VOID_TAGS:
-            self._tags.append(tag)
+            self._stack.append({
+                'hidden': hidden,
+                'slide': slide,
+                'tag': tag,
+            })
 
     def handle_startendtag(self, tag, attrs):
-        if self._active_slides:
-            self._active_slides[-1]['urls'].extend(urls_from_attrs(attrs))
-        else:
-            self.outside_urls.extend(urls_from_attrs(attrs))
+        self.handle_starttag(tag, attrs)
+        if tag.lower() not in VOID_TAGS:
+            self.handle_endtag(tag)
 
     def handle_endtag(self, tag):
         tag = tag.lower()
         if tag == 'style' and self._style_depth:
             self._style_depth -= 1
-        if tag == 'section' and self._sections:
-            slide = self._sections.pop()
-            if slide is not None:
-                self.slides.append(slide)
-                self._active_slides.pop()
-        if tag not in VOID_TAGS and self._tags:
-            self._tags.pop()
+        if tag not in VOID_TAGS and self._stack:
+            self._stack.pop()
 
     def handle_data(self, data):
         if not self._style_depth:
@@ -139,10 +269,13 @@ class SlideAssetParser(HTMLParser):
 def validate_layout_assets(pack_dir, html_path, asset_prefix):
     """Return violations of the asset contract declared by each layout."""
     pack = Pack(pack_dir)
-    required, owners = layout_asset_contract(pack)
+    owners = layout_asset_contract(pack)
     known_urls = asset_urls(pack, asset_prefix, owners)
-    if not known_urls:
-        return []
+    asset_urls_by_id = {
+        asset_id: url
+        for url, asset_ids in known_urls.items()
+        for asset_id in asset_ids
+    }
 
     with open(html_path, encoding='utf-8') as stream:
         text = stream.read()
@@ -150,10 +283,13 @@ def validate_layout_assets(pack_dir, html_path, asset_prefix):
     parser.feed(text)
     parser.close()
 
-    problems = []
+    problems = copied_asset_problems(pack, html_path, asset_prefix, owners)
+    if not parser.slides:
+        problems.append(
+            '没有识别到 deck-stage 的直属 slide section，无法核验模板页型')
+        return problems
     for url in parser.outside_urls:
-        asset_id = known_urls.get(normalized_path(url))
-        if asset_id:
+        for asset_id in sorted(known_urls.get(normalized_path(url), ())):
             problems.append(
                 '模板资产 %s 出现在 slide section 外，无法核验页型归属' % asset_id)
     for number, slide in enumerate(parser.slides, 1):
@@ -164,23 +300,102 @@ def validate_layout_assets(pack_dir, html_path, asset_prefix):
         if layout not in pack.layouts:
             problems.append('第 %d 页声明了不存在的模板页型: %s' % (number, layout))
             continue
-        used_asset_counts = Counter(
-            known_urls[normalized_path(url)]
-            for url in slide['urls']
-            if normalized_path(url) in known_urls
+        layout_entry = pack.layouts[layout][0]
+        explicit_theme = slide['theme']
+        default_theme = pack.design.data.get('default-theme')
+        active_theme = explicit_theme or default_theme
+        if explicit_theme and explicit_theme not in pack.themes:
+            problems.append(
+                '第 %d 页声明了不存在的模板主题: %s' % (number, explicit_theme))
+            continue
+        layout_themes = (
+            (layout_entry.get('themes') or [])
+            if isinstance(layout_entry, dict) else []
         )
+        if active_theme and layout_themes and active_theme not in layout_themes:
+            problems.append(
+                '第 %d 页页型 %s 不支持当前主题 %s；允许主题: %s。'
+                '若确需切换，显式声明 data-pptx-theme'
+                % (number, layout, active_theme, '、'.join(layout_themes)))
+            continue
+        expected = layout_asset_instances(
+            layout_entry, set(pack.assets), pack.canvas)
+        actual = []
+        for reference in slide['references']:
+            referenced_ids = set()
+            normalized_urls = [normalized_path(url) for url in reference['urls']]
+            for url in normalized_urls:
+                referenced_ids.update(known_urls.get(url, ()))
+            asset_id = reference['asset']
+            if not asset_id:
+                for referenced_id in sorted(referenced_ids):
+                    problems.append(
+                        '第 %d 页模板资产 %s 缺少 data-pptx-asset 实例标记'
+                        % (number, referenced_id))
+                continue
+            if asset_id not in pack.assets:
+                problems.append(
+                    '第 %d 页声明了不存在的模板资产: %s' % (number, asset_id))
+                continue
+            expected_url = asset_urls_by_id.get(asset_id)
+            uses_expected_source = (
+                len(normalized_urls) == 1
+                and normalized_urls[0] == expected_url
+                and (
+                    reference['tag'] != 'img'
+                    or (
+                        reference['source']
+                        and normalized_path(reference['source']) == expected_url
+                    )
+                )
+            )
+            if not uses_expected_source:
+                problems.append(
+                    '第 %d 页固定实例 %s 未引用对应的 PPTX 原素材'
+                    % (number, asset_id))
+            if reference['hidden']:
+                problems.append(
+                    '第 %d 页固定实例 %s 不可隐藏' % (number, asset_id))
+            actual.append({
+                'asset': asset_id,
+                'box': element_box(reference, pack.canvas),
+            })
+
+        used_asset_counts = Counter(instance['asset'] for instance in actual)
         for asset_id in sorted(used_asset_counts):
             if layout not in owners.get(asset_id, set()):
                 allowed = '、'.join(sorted(owners.get(asset_id) or ())) or '（无）'
                 problems.append(
                     '第 %d 页页型 %s 不得使用 %s；只允许: %s'
                     % (number, layout, asset_id, allowed))
-        for asset_id, required_count in sorted(required.get(layout, {}).items()):
-            missing_count = required_count - used_asset_counts[asset_id]
-            if missing_count > 0:
+        unmatched = list(actual)
+        for asset_id, _, expected_box in expected:
+            matching_index = next((
+                index for index, instance in enumerate(unmatched)
+                if instance['asset'] == asset_id
+                and boxes_match(instance['box'], expected_box)
+            ), None)
+            if matching_index is not None:
+                unmatched.pop(matching_index)
+                continue
+            same_asset = next((
+                instance for instance in unmatched
+                if instance['asset'] == asset_id
+            ), None)
+            if same_asset:
+                problems.append(
+                    '第 %d 页固定实例 %s 的位置尺寸必须为 %s，当前为 %s'
+                    % (number, asset_id, expected_box, same_asset['box']))
+                unmatched.remove(same_asset)
+            else:
+                problems.append(
+                    '第 %d 页页型 %s 缺少固定实例 %s，位置尺寸应为 %s'
+                    % (number, layout, asset_id, expected_box))
+        for instance in unmatched:
+            if layout in owners.get(instance['asset'], set()):
                 problems.append(
-                    '第 %d 页页型 %s 必须使用其绑定资产 %s 共 %d 处，当前缺少 %d 处'
-                    % (number, layout, asset_id, required_count, missing_count))
+                    '第 %d 页页型 %s 额外使用了固定实例 %s'
+                    % (number, layout, instance['asset']))
     return problems
 
 

package/steering/design-html/skills/slide-deck/SKILL.md

@@ -45,6 +45,8 @@ metadata:
 
 deck-stage 组件会对每个 slotted 子元素做绝对定位——**绝不**在幻灯片 `<section>` 元素上自行设置 position/inset/width/height。
 
+组件撑满的只是 `<section>` 本身，section 内的容器高度仍由内容撑开；高度由内容撑开的容器上，`justify-content` 等垂直分布声明静默无效。要垂直居中或上下分布，先给承载声明的容器高度（如 `height: 100%`）。
+
 ### 使用 PPTX 风格包
 
 如果前一步产出了 `pptx-style-extract` 风格包，必须把它当作本 deck 的设计系统：
@@ -104,7 +106,7 @@ deck-stage 组件会对每个 slotted 子元素做绝对定位——**绝不**
 
 - **动效。** 动效服务于叙事——引导视线、分层揭示信息、平滑衔接页面——而不是炫技或填空。默认克制，始终以不干扰阅读为底线。deck 动效的形态是**翻到该页时播放一次的入场 / 分步揭示**，不做环境循环——无限循环的装饰动画会持续争夺注意力。实现用 CSS 动画（幻灯片保持可直编的静态 HTML），两条契约（细节见 deck-stage.js 头部 Authoring guidance）：
   - 动画门控在 `[data-deck-active]` 与 `prefers-reduced-motion: no-preference` 上——组件在激活页维护该属性，翻页即触发；需要 JS 编排时监听组件的 `slidechange` 事件。
-  - 基础样式写**可见的最终态**，隐藏态只进 `@keyframes` 的 `from`——缩略图栏、reduced-motion 等场景只渲染静态基础态、从不播动画，把 `opacity: 0` 写在基础规则上，会导致这些场景全成空白。
+  - 基础样式写的就是**动画结束后的最终画面**，`@keyframes` 只描述进入它的路径——判据：删掉所有 `animation` 声明，静止画面应一个像素不变（缩略图栏、print、reduced-motion 渲染的正是这个无动画基态）。
 
 - **层次靠版式，不靠特效。** 页内层级由字号、字重、色块、边框、分隔线和留白建立；内容卡片和区块默认平面化——不加 box-shadow、发光、玻璃拟态（backdrop-filter + 半透明底），渐变默认只用于图上文字的保护渐变（见「图片呈现」）和数据可视化的连续色带。深色底 + 紫蓝渐变 + 发光卡片的「科技感」组合是模型默认值而非设计选择（frontend-design 校准清单第 4 种长相），除非品牌 / brief 明确要求，不要用它。
 
@@ -135,7 +137,7 @@ deck-stage 组件会对每个 slotted 子元素做绝对定位——**绝不**
 
 ## 规划步骤
 
-在常规规划之外，务必完成以下步骤：
+务必完成以下步骤：
 
 1. 如果不清楚受众、期望的品牌风格，先提问。
 2. 写出完整的标题序列。选择**一种**语法风格（例如短主题名词短语或简短陈述句），确保适合内容，并用该风格写出每一个标题。回头通读一遍，判断一个人**仅凭标题**能否跟上整个演示的脉络。标题应像书的章节——用直白的语言告诉读者接下来是什么。审阅这些标题并按需修订。将它们写入 scratchpad.md 文件。
@@ -162,4 +164,4 @@ deck-stage 组件会对每个 slotted 子元素做绝对定位——**绝不**
 - 没有被动空洞：边框 / 底色圈出的范围与其内容相称
 - 页面视觉重量在画布上分布均衡，没有大片区域读成「缺了东西」
 - 每页能指出视觉锚点；版式原型的重复经得起「内容使然还是没做选择」的追问
-- 带动效的元素在缩略图栏和打印视图下完整可见（基础样式即最终态，隐藏态只在 keyframes 的 `from` 里）
+- 带动效的元素在缩略图栏和打印视图下与激活页一致（基础样式即动画终态——删掉 `animation` 声明，静止画面不变）