crates/laymesh-language/src/lib.rs 1//! Static, non-evaluating language services shared by native LSP and WebAssembly.2mod bindings;3mod colors;4mod connections;5mod file_references;6mod formatting;7mod index;8pub mod inspect;9pub mod lsp;10pub mod stylesheets;11use index::{Symbol, Token, index, tokens};12use laymesh_core::{13 engine::{API, predefined_value, predefined_variables},14 parser::{self, Expr, ExprKind, Stmt, StmtKind},15};16use regex::Regex;17use serde_json::{Value as J, json};18use std::collections::{BTreeMap, BTreeSet};19use std::{20 cell::RefCell,21 hash::{Hash, Hasher},22};23#[derive(Default)]24pub struct LanguageService {25 pub documents: BTreeMap<String, String>,26 pub locale: String,27 stylesheet_indexes: RefCell<BTreeMap<String, (u64, std::sync::Arc<stylesheets::Index>)>>,28 indexes: RefCell<BTreeMap<String, (u64, bool, index::Index)>>,29 bindings: RefCell<Option<(u64, bindings::Graph)>>,30}31#[derive(Default)]32struct Context {33 name: String,34 receiver: String,35 parameter: String,36 used: Vec<String>,37 positional: usize,38 prefix: String,39}40// Restrict library suggestions to stylesheet arguments and CSS import paths;41// arbitrary strings and comments must keep their ordinary editor behavior.42fn stylesheet_range(source: &str, offset: usize, css: bool) -> Option<(usize, usize, bool)> {43 let offset = offset.min(source.len());44 if let Some(t) = tokens(source)45 .into_iter()46 .find(|t| t.kind == "string" && t.from < offset && offset <= t.to)47 {48 let quote = t.text.chars().next()?;49 if !matches!(quote, '\'' | '"') {50 return None;51 }52 let import = css53 && Regex::new(r"(?s)@import\s+(?:url\(\s*)?$")54 .unwrap()55 .is_match(&source[..t.from]);56 let argument = !css && context(source, t.from).is_some_and(|c| c.parameter == "stylesheet");57 if import || argument {58 return Some((59 t.from + 1,60 t.to - usize::from(t.text.len() > 1 && t.text.ends_with(quote)),61 true,62 ));63 }64 }65 if css66 && Regex::new(r"(?s)@import\s+(?:url\(\s*)?$")67 .unwrap()68 .is_match(&source[..offset])69 {70 return Some((offset, offset, false));71 }72 if !css73 && context(source, offset).is_some_and(|c| c.parameter == "stylesheet")74 && source[..offset].trim_end().ends_with(['=', '[', ','])75 {76 return Some((offset, offset, false));77 }78 None79}80fn stylesheet_doc(library: &laymesh_core::style::StylesheetMetadata, en: bool) -> String {81 format!(82 "**{} {}** · {}\n\n`{}`\n\n{}\n\nSHA-256: `{}`",83 library.name,84 library.version,85 library.license,86 library.path(),87 if en {88 "Bundled offline. Explicitly import with canvas(stylesheet=...) or CSS @import. Inline style blocks allow one .lay file; shared themes are optional."89 } else {90 "离线内置,需通过 canvas(stylesheet=...) 或 CSS @import 显式导入。内嵌 style 可使用单个 .lay 文件;共享主题是可选的。"91 },92 library.sha25693 ) + &format!(94 "\n\n[{}]({})",95 if en {96 "Upstream source"97 } else {98 "上游来源"99 },100 library.source101 )102}103pub(crate) fn resolve(uri: &str, relative: &str) -> String {104 if let Some(path) = uri.strip_prefix("file://") {105 // URI paths are independent of the host filesystem's separators.106 let (authority, path) = if path.starts_with('/') {107 ("", path)108 } else {109 path.split_once('/').unwrap_or((path, ""))110 };111 let relative = if cfg!(windows) {112 relative.replace('\\', "/")113 } else {114 relative.to_owned()115 };116 let mut encoded = String::new();117 for byte in relative.bytes() {118 if byte.is_ascii_alphanumeric() || b"-._~/:".contains(&byte) {119 encoded.push(byte as char);120 } else {121 encoded.push_str(&format!("%{byte:02X}"));122 }123 }124 let drive_path = relative.as_bytes().get(1) == Some(&b':')125 && relative126 .as_bytes()127 .first()128 .is_some_and(u8::is_ascii_alphabetic);129 let joined = if drive_path {130 format!("/{encoded}")131 } else if encoded.starts_with('/') {132 encoded133 } else {134 format!(135 "{}/{encoded}",136 path.rsplit_once('/')137 .map(|(parent, _)| parent)138 .unwrap_or("")139 )140 };141 let mut parts: Vec<&str> = Vec::new();142 for part in joined.split('/') {143 match part {144 "" | "." => {}145 ".." => {146 if !(parts.len() == 1 && parts[0].ends_with(':')) {147 parts.pop();148 }149 }150 _ => parts.push(part),151 }152 }153 format!("file://{authority}/{}", parts.join("/"))154 } else {155 laymesh_core::model::resolve(uri, relative)156 }157}158fn strs(j: &J) -> Vec<String> {159 j.as_array()160 .map(|a| {161 a.iter()162 .filter_map(|v| v.as_str().map(str::to_string))163 .collect()164 })165 .unwrap_or_default()166}167fn api() -> &'static J {168 &laymesh_core::engine::API169}170fn entries() -> &'static Vec<J> {171 API["api"].as_array().unwrap()172}173fn entry(name: &str) -> Option<J> {174 entries().iter().find(|a| a["name"] == name).cloned()175}176fn desc<'a>(p: &'a J, en: bool) -> &'a str {177 p[if en { "descriptionEn" } else { "description" }]178 .as_str()179 .unwrap_or("")180}181fn link(name: &str, en: bool) -> String {182 format!(183 "[{}](https://muxkin.github.io/LayMesh/{}docs/topics/interface-reference{}.html#{})",184 if en { "Documentation" } else { "文档" },185 if en { "en/" } else { "" },186 if en { "" } else { ".zh-CN" },187 name.replace('.', "-")188 )189}190fn parameter_doc(p: &J, en: bool, owner: &str) -> String {191 let mut out = vec![192 format!(193 "**{}** — `{}`",194 p["name"].as_str().unwrap_or(""),195 parameter_type(p)196 ),197 desc(p, en).into(),198 ];199 for value in strs(&p["values"]) {200 let explanation = p["valueDescriptions"][&value][if en { "en" } else { "zh" }]201 .as_str()202 .unwrap_or("");203 out.push(format!("`{value}`: {explanation}"));204 }205 if let Some(parent) = p["defaultFrom"].as_str() {206 out.push(format!(207 "{} `{parent}`",208 if en {209 "Default inherits"210 } else {211 "默认继承"212 }213 ));214 }215 if p["unit"] != "none" {216 out.push(format!(217 "{}: {}",218 if en { "Unit" } else { "单位" },219 if p["unit"] == "geometry" {220 "figure unit (default mm)"221 } else {222 p["unit"].as_str().unwrap_or("")223 }224 ))225 }226 if let Some(d) = p["default"].as_str() {227 out.push(format!("{}: `{d}`", if en { "Default" } else { "默认" }))228 }229 if let Some(e) = p["example"].as_str() {230 out.push(format!("```lay\n{e}\n```"))231 }232 if !owner.is_empty() {233 out.push(link(owner, en));234 }235 out.into_iter()236 .filter(|s| !s.is_empty())237 .collect::<Vec<_>>()238 .join("\n\n")239}240fn parameter_type(p: &J) -> String {241 let values = strs(&p["values"]);242 if values.is_empty() {243 return p["type"].as_str().unwrap_or("value").into();244 }245 let mut typ = values246 .iter()247 .map(|v| format!("\"{v}\""))248 .collect::<Vec<_>>()249 .join(" | ");250 if p["name"] == "anchor" && values.contains(&"top_left".into()) {251 typ.push_str(" | self selector");252 }253 if p["type"].as_str().is_some_and(|t| t.contains("boolean")) {254 typ.push_str(" | boolean");255 }256 if p["name"] == "position" {257 typ.push_str(" | (length, length)");258 }259 typ260}261fn variable_doc(name: &str, value: &str) -> String {262 format!("```lay\n{name}: string = {}\n```", json!(value))263}264fn builtin(name: &str, en: bool) -> Option<J> {265 let e = entry(name)?;266 let mut names = strs(&e["positional"]);267 for p in e["parameters"].as_array().unwrap() {268 let n = p["name"].as_str().unwrap().to_string();269 if !names.contains(&n) {270 names.push(n)271 }272 }273 let ps:Vec<J>=names.iter().map(|n|{let p=e["parameters"].as_array().unwrap().iter().find(|p|p["name"]==*n).cloned().or_else(||if n=="material"{None}else{entries().iter().flat_map(|a|a["parameters"].as_array().unwrap()).find(|p|p["name"]==*n).cloned()}).unwrap_or(json!({"name":n,"type":"material","description":"需要放置的素材。","descriptionEn":"Material to place."}));let positional=strs(&e["positional"]).contains(n);let named=e["parameters"].as_array().unwrap().iter().any(|p|p["name"]==*n);json!({"name":n,"type":parameter_type(&p),"description":desc(&p,en),"unit":p["unit"],"example":p["example"],"documentation":parameter_doc(&p,en,name),"default":p["default"],"required":strs(&e["required"]).contains(n),"kind":if positional{if named{"either"}else{"positional"}}else{"named"},"label":[0,0]})}).collect();274 Some(275 json!({"name":name,"summary":desc(&e,en),"returns":e["returns"][if en{"en"}else{"zh"}],"documentation":format!("{}\n\n{}",desc(&e,en),link(name,en)),"parameters":ps}),276 )277}278fn authored(s: &Symbol, name: &str, en: bool) -> J {279 let d = s.doc.select(en);280 let ps:Vec<J>=s.parameters.iter().map(|p|{let n=p["name"].as_str().unwrap();let info=d.parameters.get(n).cloned().unwrap_or(json!({}));let default=p["default"].clone();json!({"name":n,"type":info["type"].as_str().unwrap_or("value"),"description":info["description"].as_str().unwrap_or(""),"default":default,"required":default.is_null(),"kind":"either","documentation":format!("**{n}**\n\n{}{}",info["description"].as_str().unwrap_or(""),default.as_str().map(|s|format!("\n\n{}: `{s}`",if en{"Default"}else{"默认"})).unwrap_or_default()),"label":[0,0]})}).collect();281 json!({"name":name,"summary":d.body.split("\n\n").next().unwrap_or(""),"documentation":s.doc.markdown(en),"parameters":ps})282}283fn word(source: &str, offset: usize) -> (usize, usize, String) {284 let mut a = offset.min(source.len());285 while a > 0286 && source.as_bytes()[a - 1].is_ascii()287 && (source.as_bytes()[a - 1].is_ascii_alphanumeric()288 || b"_-".contains(&source.as_bytes()[a - 1]))289 {290 a -= 1291 }292 let mut b = offset.min(source.len());293 while b < source.len()294 && (source.as_bytes()[b].is_ascii_alphanumeric() || b"_-".contains(&source.as_bytes()[b]))295 {296 b += 1297 }298 (a, b, source[a..b].into())299}300fn receiver_before(source: &str, offset: usize) -> Option<String> {301 let ts: Vec<Token> = tokens(&source[..offset.min(source.len())])302 .into_iter()303 .filter(|t| t.kind != "comment")304 .collect();305 if ts.last()?.text != "." {306 return None;307 }308 let end = ts.last()?.from;309 let mut depth = 0;310 let mut start = end;311 for t in ts[..ts.len() - 1].iter().rev() {312 if depth == 0 && start < end && source[t.to..start].contains('\n') {313 break;314 }315 match t.text.as_str() {316 ")" | "]" | "}" => depth += 1,317 "(" | "[" | "{" if depth > 0 => depth -= 1,318 "(" | "[" | "{" => break,319 _ if depth == 0 && t.text != "." && t.kind != "name" => break,320 _ => {}321 }322 if depth == 0 && start < end && source[t.to..start].contains('\n') {323 break;324 }325 start = t.from;326 }327 (start < end).then(|| source[start..end].trim().to_string())328}329fn expression(source: &str) -> Option<Expr> {330 let stmts = parser::parse(&format!("__probe={source}"), "<completion>").ok()?;331 match stmts.into_iter().next()?.kind {332 StmtKind::Bind(_, e, _) => Some(e),333 _ => None,334 }335}336fn type_info(typ: &str) -> &'static J {337 let typ = if typ == "table" { "dict" } else { typ };338 if API["valueTypes"].get(typ).is_some() {339 &API["valueTypes"][typ]340 } else {341 &API["geometryTypes"][typ]342 }343}344fn geometry_member_type(typ: &str, name: &str) -> Option<String> {345 type_info(typ)["members"][name].as_str().map(str::to_string)346}347fn geometry_surface(name: &str) -> Option<String> {348 entries()349 .iter()350 .find(|e| {351 e["geometryMethod"] == true352 && e["name"].as_str().unwrap().rsplit('.').next() == Some(name)353 })354 .and_then(|e| e["name"].as_str().map(str::to_string))355}356fn expression_type(e: &Expr, lookup: &impl Fn(&str) -> Option<String>) -> Option<String> {357 match &e.kind {358 ExprKind::Number(_, _) => Some("number".into()),359 ExprKind::String(_, _, _) => Some("string".into()),360 ExprKind::Bool(_) => Some("bool".into()),361 ExprKind::Unary(op, value) => {362 if op == "not" {363 Some("bool".into())364 } else {365 expression_type(value, lookup)366 }367 }368 ExprKind::Binary(op, a, b) => {369 if ["==", "!=", "<", ">", "<=", ">=", "and", "or"].contains(&op.as_str()) {370 Some("bool".into())371 } else {372 let a = expression_type(a, lookup)?;373 let b = expression_type(b, lookup)?;374 (a == b).then_some(a)375 }376 }377 ExprKind::Dict(_) => Some("dict".into()),378 ExprKind::List(_) => Some("list".into()),379 ExprKind::Ref(ps) => {380 let mut typ = if ps[0] == "self" {381 "instance".into()382 } else {383 lookup(&ps[0])?384 };385 for member in &ps[1..] {386 typ = geometry_member_type(&typ, member)?;387 }388 Some(typ)389 }390 ExprKind::Member(receiver, name) => {391 geometry_member_type(&expression_type(receiver, lookup)?, name)392 }393 ExprKind::Index(receiver, _) => type_info(&expression_type(receiver, lookup)?)["index"]394 .as_str()395 .map(str::to_string),396 ExprKind::Method(receiver, name, _) => {397 type_info(&expression_type(receiver, lookup)?)["methods"][name]398 .as_str()399 .map(str::to_string)400 }401 ExprKind::Call(ps, _) => {402 if ps.len() == 2403 && lookup(&ps[0]).is_none()404 && entry(&ps.join(".")).is_some_and(|e| e["namespaceConstructor"] == true)405 {406 return Some(ps.join("."));407 }408 if ps.len() == 1 {409 if ps[0] == "add" && lookup("add").is_none() {410 return Some("instance".into());411 }412 return Some(413 entry(&ps[0])414 .and_then(|a| a["returnType"].as_str().map(str::to_string))415 .unwrap_or_else(|| ps[0].clone()),416 );417 }418 let mut typ = if ps[0] == "self" {419 "instance".into()420 } else {421 lookup(&ps[0])?422 };423 for member in &ps[1..ps.len() - 1] {424 typ = geometry_member_type(&typ, member)?;425 }426 let method = ps.last()?;427 if typ == "canvas" && method == "step" {428 return Some("step".into());429 }430 if method == "add" || method == "fuse" {431 return Some(432 if typ == "document" {433 "page"434 } else {435 "instance"436 }437 .into(),438 );439 }440 type_info(&typ)["methods"][method]441 .as_str()442 .map(str::to_string)443 .or_else(|| matches!(method.as_str(), "data" | "axis").then(|| "anchor".into()))444 }445 }446}447fn context(source: &str, offset: usize) -> Option<Context> {448 let ts: Vec<Token> = tokens(&source[..offset.min(source.len())])449 .into_iter()450 .filter(|t| t.kind != "comment")451 .collect();452 let mut stack = vec![];453 for (i, t) in ts.iter().enumerate() {454 if ["(", "[", "{"].contains(&t.text.as_str()) {455 stack.push(i)456 } else if [")", "]", "}"].contains(&t.text.as_str()) {457 let open = match t.text.as_str() {458 ")" => "(",459 "]" => "[",460 _ => "{",461 };462 if let Some(at) = stack.iter().rposition(|&j| ts[j].text == open) {463 stack.truncate(at)464 }465 }466 }467 let &at = stack.iter().rev().find(|&&i| {468 ts[i].text == "("469 && i > 0470 && ts[i - 1].kind == "name"471 && (i < 2 || ts[i - 2].text != "function")472 })?;473 let mut c = Context {474 name: ts[at - 1].text.clone(),475 ..Context::default()476 };477 if at >= 3 && ts[at - 2].text == "." {478 c.receiver = receiver_before(source, ts[at - 2].to).unwrap_or_default()479 }480 let mut depth = 0;481 let mut start = at + 1;482 for i in at + 1..ts.len() {483 let t = &ts[i];484 if ["(", "[", "{"].contains(&t.text.as_str()) {485 depth += 1486 } else if [")", "]", "}"].contains(&t.text.as_str()) {487 depth -= 1488 } else if depth == 0 {489 if t.text == "," {490 if c.parameter.is_empty() && i > start {491 c.positional += 1492 }493 c.parameter.clear();494 start = i + 1;495 }496 if i == start && t.kind == "name" && ts.get(i + 1).is_some_and(|t| t.text == "=") {497 c.parameter = t.text.clone();498 c.used.push(t.text.clone());499 }500 }501 }502 if ts.len() == start + 1 && ts[start].kind == "name" {503 c.prefix = ts[start].text.clone()504 }505 Some(c)506}507impl LanguageService {508 pub fn new(locale: &str) -> Self {509 Self {510 documents: BTreeMap::new(),511 locale: locale.into(),512 ..Self::default()513 }514 }515 pub fn update(&mut self, uri: &str, text: &str) {516 self.documents.insert(uri.into(), text.into());517 }518 pub fn remove(&mut self, uri: &str) {519 self.documents.remove(uri);520 }521 fn en(&self) -> bool {522 !self.locale.to_lowercase().starts_with("zh")523 }524 fn source(&self, uri: &str) -> &str {525 self.documents.get(uri).map(String::as_str).unwrap_or("")526 }527 fn document_index(&self, uri: &str) -> index::Index {528 let source = self.source(uri);529 let mut hasher = std::collections::hash_map::DefaultHasher::new();530 source.hash(&mut hasher);531 let hash = hasher.finish();532 let en = self.en();533 let mut cached = self.indexes.borrow_mut();534 if !cached535 .get(uri)536 .is_some_and(|(h, e, _)| *h == hash && *e == en)537 {538 cached.insert(uri.into(), (hash, en, index(uri, source, en)));539 }540 cached[uri].2.clone()541 }542 fn binding_graph(&self) -> bindings::Graph {543 let mut hasher = std::collections::hash_map::DefaultHasher::new();544 self.documents.hash(&mut hasher);545 self.locale.hash(&mut hasher);546 let hash = hasher.finish();547 if self548 .bindings549 .borrow()550 .as_ref()551 .is_none_or(|(old, _)| *old != hash)552 {553 let graph = bindings::Graph::build(self);554 *self.bindings.borrow_mut() = Some((hash, graph));555 }556 self.bindings.borrow().as_ref().unwrap().1.clone()557 }558 fn visible(&self, uri: &str, offset: usize) -> Vec<Symbol> {559 let mut symbols = self.document_index(uri).symbols;560 symbols.retain(|s| {561 s.scope_from <= offset562 && s.scope_to >= offset563 && (s.from <= offset || s.kind == "function")564 });565 symbols.sort_by_key(|s| (usize::MAX - (s.scope_to - s.scope_from), s.from));566 let mut out = BTreeMap::new();567 for s in symbols {568 out.insert(s.name.clone(), s);569 }570 out.into_values().collect()571 }572 fn resolve(573 &self,574 uri: &str,575 name: &str,576 offset: usize,577 seen: &mut BTreeSet<String>,578 ) -> Option<Symbol> {579 if !seen.insert(format!("{uri}:{name}:{offset}")) {580 return None;581 }582 if let Some(s) = self583 .visible(uri, offset)584 .into_iter()585 .find(|s| s.name == name)586 {587 if !s.alias.is_empty() && s.doc.body.is_empty() && s.doc.variants.is_empty() {588 if let Some(target) = self.resolve(uri, &s.alias, s.from.saturating_sub(1), seen) {589 if target.kind == "function" {590 return Some(target);591 }592 }593 }594 return Some(s);595 }596 for imp in self.document_index(uri).imports {597 if imp.alias == name598 && imp.scope_from <= offset599 && imp.scope_to >= offset600 && imp.alias_from <= offset601 {602 let target = resolve(uri, &imp.source);603 let s = self604 .document_index(&target)605 .symbols606 .into_iter()607 .find(|s| s.exported && s.scope_from == 0 && s.name == imp.name)?;608 return if !s.alias.is_empty() {609 self.resolve(&target, &s.alias, s.from.saturating_sub(1), seen)610 .filter(|target| target.kind == "function")611 .or(Some(s))612 } else {613 Some(s)614 };615 }616 }617 None618 }619 fn named(&self, uri: &str, offset: usize) -> Vec<(String, Symbol)> {620 let mut out: BTreeMap<String, Symbol> = self621 .visible(uri, offset)622 .into_iter()623 .map(|s| (s.name.clone(), s))624 .collect();625 for imp in self.document_index(uri).imports {626 if !out.contains_key(&imp.alias) {627 if let Some(s) = self.resolve(uri, &imp.alias, offset, &mut BTreeSet::new()) {628 out.insert(imp.alias, s);629 }630 }631 }632 out.into_iter().collect()633 }634 fn type_of(&self, uri: &str, name: &str, offset: usize) -> Option<String> {635 self.type_of_inner(uri, name, offset, &mut BTreeSet::new())636 }637 fn type_of_inner(638 &self,639 uri: &str,640 name: &str,641 offset: usize,642 active: &mut BTreeSet<String>,643 ) -> Option<String> {644 if !active.insert(format!("{uri}:{name}:{offset}")) {645 return None;646 }647 let symbol = self.resolve(uri, name, offset, &mut BTreeSet::new())?;648 let declared = symbol.doc.select(self.en()).typ;649 if !declared.is_empty() {650 return Some(declared);651 }652 if let Some(factory) =653 self.resolve(&symbol.uri, &symbol.typ, symbol.from, &mut BTreeSet::new())654 {655 if let Some(returns) = factory.doc.select(self.en()).returns {656 if let Some(typ) = returns["type"].as_str() {657 return Some(typ.into());658 }659 }660 }661 if let Some(value) = &symbol.value {662 if let Some(inferred) = expression_type(value, &|other| {663 self.type_of_inner(664 &symbol.uri,665 other,666 symbol.from.saturating_sub(1),667 &mut active.clone(),668 )669 }) {670 return Some(inferred);671 }672 }673 if symbol.typ.is_empty() {674 let source = self.source(&symbol.uri);675 let tail = &source[symbol.to..];676 if let Some(rhs) = tail.trim_start().strip_prefix('=') {677 if let Some(expr) = expression(rhs.split('\n').next().unwrap_or("")) {678 let inferred = expression_type(&expr, &|other| {679 if other == name {680 None681 } else {682 self.type_of_inner(&symbol.uri, other, symbol.from, &mut active.clone())683 }684 });685 if inferred.is_some() {686 return inferred;687 }688 }689 }690 }691 Some(symbol.typ)692 }693 fn receiver_type(&self, uri: &str, receiver: &str, offset: usize) -> Option<String> {694 expression_type(&expression(receiver)?, &|name| {695 self.type_of(uri, name, offset)696 })697 }698 fn callable(&self, uri: &str, offset: usize, c: &Context) -> Option<J> {699 if c.receiver == "arrow"700 && self701 .resolve(uri, "arrow", offset, &mut BTreeSet::new())702 .is_none()703 {704 return builtin(&format!("arrow.{}", c.name), self.en());705 }706 if c.receiver.is_empty() {707 if let Some(s) = self.resolve(uri, &c.name, offset, &mut BTreeSet::new()) {708 return if s.kind == "function" {709 Some(authored(&s, &c.name, self.en()))710 } else {711 None712 };713 }714 }715 let mut name = c.name.clone();716 if !c.receiver.is_empty() {717 if let Some(typ) = self.receiver_type(uri, &c.receiver, offset) {718 if let Some(prefix) = type_info(&typ)["methodPrefix"].as_str() {719 if type_info(&typ)["methods"][&name].is_string() {720 return builtin(&format!("{prefix}.{name}"), self.en());721 }722 }723 if ["plot", "polar_plot", "radar_plot"].contains(&typ.as_str()) {724 name = format!("plot.{name}")725 } else if typ == "instance" && ["data", "axis"].contains(&name.as_str()) {726 name = format!("instance.{name}")727 }728 }729 }730 builtin(&name, self.en())731 }732 pub fn signature(&self, uri: &str, offset: usize) -> J {733 let Some(c) = context(self.source(uri), offset) else {734 return J::Null;735 };736 let Some(mut entry) = self.callable(uri, offset, &c) else {737 return J::Null;738 };739 let mut label = format!("{}(", entry["name"].as_str().unwrap());740 let ps = entry["parameters"].as_array_mut().unwrap();741 for (i, p) in ps.iter_mut().enumerate() {742 if i > 0 {743 label.push_str(", ")744 }745 let from = label.encode_utf16().count();746 label.push_str(p["name"].as_str().unwrap());747 if let Some(d) = p["default"].as_str() {748 label.push('=');749 label.push_str(d)750 }751 p["label"] = json!([from, label.encode_utf16().count()]);752 }753 label.push(')');754 let active = if !c.parameter.is_empty() {755 ps.iter().position(|p| p["name"] == c.parameter)756 } else {757 let positional: Vec<usize> = ps758 .iter()759 .enumerate()760 .filter(|(_, p)| p["kind"] != "named")761 .map(|(i, _)| i)762 .collect();763 let candidate = positional.get(c.positional).copied().filter(|&i| {764 !c.used765 .contains(&ps[i]["name"].as_str().unwrap().to_string())766 });767 if candidate.is_some() && c.prefix.is_empty() {768 candidate769 } else {770 let consumed: BTreeSet<usize> =771 positional.iter().take(c.positional).copied().collect();772 let eligible: Vec<usize> = ps773 .iter()774 .enumerate()775 .filter(|(i, p)| {776 p["kind"] != "positional"777 && !consumed.contains(i)778 && !c.used.contains(&p["name"].as_str().unwrap().to_string())779 && (c.prefix.is_empty()780 || p["name"].as_str().unwrap().starts_with(&c.prefix))781 })782 .map(|(i, _)| i)783 .collect();784 if c.prefix.is_empty() || eligible.len() == 1 {785 eligible.first().copied()786 } else {787 None788 }789 }790 };791 entry["label"] = json!(label);792 if let Some(i) = active {793 entry["activeParameter"] = json!(i);794 }795 entry796 }797 pub fn hover(&self, uri: &str, offset: usize) -> J {798 let source = self.source(uri);799 if let Some((from, to, name, kind)) = self.stylesheet_at(uri, offset) {800 let matches: Vec<_> = self801 .stylesheet_symbols(uri)802 .into_iter()803 .filter(|s| s.name == name && s.kind == kind)804 .collect();805 if !matches.is_empty() {806 return json!({"from":from,"to":to,"contents":matches.iter().map(|s|s.documentation(self.en())).collect::<Vec<_>>().join("\n\n")});807 }808 }809 let css =810 uri.ends_with(".lcss") || uri.ends_with(".css") || css_region(source, offset).is_some();811 if let Some((from, to, _)) = stylesheet_range(source, offset, css) {812 if let Some(library) = laymesh_core::style::bundled_stylesheets()813 .iter()814 .find(|l| l.path() == source[from..to])815 {816 return json!({"from":from,"to":to,"contents":stylesheet_doc(library,self.en())});817 }818 }819 let (from, to, w) = word(source, offset);820 if w.is_empty() {821 return J::Null;822 }823 let en = self.en();824 let canonical = w.replace('-', "_");825 if source[to..].trim_start().starts_with('=') {826 if let Some(c) = context(source, from) {827 if let Some(e) = self.callable(uri, offset, &c) {828 if let Some(p) = e["parameters"]829 .as_array()830 .unwrap()831 .iter()832 .find(|p| p["name"] == canonical)833 {834 return json!({"from":from,"to":to,"contents":p["documentation"]});835 }836 }837 }838 }839 if (uri.ends_with(".lcss") || uri.ends_with(".css")) || css_region(source, offset).is_some()840 {841 if let Some((_, zh, en_text)) = MOTION_PROPERTIES.iter().find(|(name, _, _)| *name == w)842 {843 return json!({"from":from,"to":to,"contents":if en{en_text}else{zh}});844 }845 if let Some(p) = api()["cssProperties"]846 .as_array()847 .unwrap()848 .iter()849 .find(|p| p["name"] == w.replace('_', "-"))850 {851 return json!({"from":from,"to":to,"contents":parameter_doc(p,en,"")});852 }853 }854 let graph = self.binding_graph();855 let binding = graph.at(uri, offset);856 if let Some(s) = binding.and_then(|o| {857 self.resolve(uri, &w, offset, &mut BTreeSet::new())858 .or_else(|| {859 graph860 .indexes861 .get(&o.key.uri)?862 .symbols863 .iter()864 .find(|s| s.from == o.key.from)865 .cloned()866 })867 }) {868 let contents = if s.kind == "function" {869 let e = authored(&s, &w, en);870 format!(871 "```lay\n{}({})\n```\n\n{}",872 w,873 s.parameters874 .iter()875 .map(|p| p["name"].as_str().unwrap())876 .collect::<Vec<_>>()877 .join(", "),878 e["documentation"].as_str().unwrap()879 )880 } else {881 let typ = self882 .type_of(uri, &w, offset)883 .filter(|t| !t.is_empty())884 .or_else(|| (!s.doc.select(en).typ.is_empty()).then(|| s.doc.select(en).typ))885 .unwrap_or_else(|| "value".into());886 format!("```lay\n{w}: {typ}\n```\n\n{}", s.doc.markdown(en))887 };888 return json!({"from":from,"to":to,"contents":contents});889 }890 if !source[to..].trim_start().starts_with('(')891 && receiver_before(source, from).is_none()892 && !tokens(source)893 .iter()894 .any(|t| matches!(t.kind, "string" | "comment") && t.from <= from && t.to >= to)895 {896 if let Some(value) = predefined_value(&w) {897 return json!({"from":from,"to":to,"contents":variable_doc(&w,value)});898 }899 }900 let receiver = receiver_before(source, from).unwrap_or_default();901 let c = Context {902 name: w,903 receiver,904 ..Context::default()905 };906 if let Some(e) = self.callable(uri, offset, &c) {907 return json!({"from":from,"to":to,"contents":format!("```lay\n{}(...)\n```\n\n{}",e["name"].as_str().unwrap(),e["documentation"].as_str().unwrap())});908 }909 if let Some(typ) = self910 .receiver_type(uri, &c.receiver, offset)911 .and_then(|typ| geometry_member_type(&typ, &c.name))912 {913 return json!({"from":from,"to":to,"contents":format!("**{}** → `{typ}`\n\n{}",c.name,desc(&type_info(&typ),en))});914 }915 J::Null916 }917 pub fn definition(&self, uri: &str, offset: usize) -> J {918 let css = self.stylesheet_definition(uri, offset);919 if !css.is_null() {920 return css;921 }922 let source = self.source(uri);923 let (_, _, w) = word(source, offset);924 let graph = self.binding_graph();925 if let Some(o) = graph.at(uri, offset) {926 if let Some(s) = self927 .resolve(uri, &w, offset, &mut BTreeSet::new())928 .filter(|s| s.kind == "function")929 {930 return json!({"uri":s.uri,"from":s.from,"to":s.to});931 }932 if let Some(definition) = graph.definition(&o.key) {933 return definition;934 }935 }936 if let Some(t) = tokens(source)937 .iter()938 .find(|t| t.from <= offset && t.to >= offset && t.kind == "string")939 {940 let p = t.text.trim_matches(['\'', '"']);941 let target = resolve(uri, p);942 if self.documents.contains_key(&target) {943 return json!({"uri":target,"from":0,"to":0});944 }945 }946 if !w.is_empty() {947 let pattern = format!(948 r"(?:\.|--){}(?:\s|\{{|:)",949 regex::escape(w.trim_start_matches('-'))950 );951 let re = Regex::new(&pattern).unwrap();952 for (file, text) in &self.documents {953 if let Some(m) = re.find(text) {954 return json!({"uri":file,"from":m.start(),"to":m.end()-1});955 }956 }957 }958 J::Null959 }960 pub fn completions(&self, uri: &str, offset: usize) -> J {961 let source = self.source(uri);962 let offset = offset.min(source.len());963 let before = &source[..offset];964 let line = before.rsplit('\n').next().unwrap();965 let (from, to, _) = word(source, offset);966 let en = self.en();967 let option = |label: &str, kind: &str, info: String, apply: String, detail: &str| json!({"label":label,"type":kind,"info":info,"apply":apply,"detail":detail,"from":from,"to":to});968 if line.trim_start().starts_with("##") {969 let mut out = vec![];970 let decl = index(uri, source, en)971 .symbols972 .into_iter()973 .find(|s| s.kind == "function" && s.from > offset);974 if line.contains("@lang ") {975 for tag in ["zh-CN", "en"] {976 out.push(option(977 tag,978 "text",979 String::new(),980 tag.into(),981 "Documentation",982 ))983 }984 } else if line.contains("@param ") {985 if let Some(s) = decl {986 let section = before.rsplit("## @lang").next().unwrap_or(before);987 for p in s.parameters {988 let n = p["name"].as_str().unwrap();989 if !Regex::new(&format!(990 r"@param\s+(?:\{{[^}}]*\}}\s*)?{}\b",991 regex::escape(n)992 ))993 .unwrap()994 .is_match(section)995 {996 out.push(option(997 n,998 "text",999 String::new(),1000 format!("{n} - "),1001 "Documentation",1002 ))1003 }1004 }1005 }1006 } else if line.trim() == "##" {1007 let params = decl.map(|s| s.parameters).unwrap_or_default();1008 let build = |english| {1009 let mut a = vec![if english {1010 "Describe this declaration.".into()1011 } else {1012 "说明此声明的用途。".into()1013 }];1014 for p in ¶ms {1015 a.push(format!(1016 "@param {} - {}",1017 p["name"].as_str().unwrap(),1018 if english {1019 "Description."1020 } else {1021 "参数说明。"1022 }1023 ))1024 }1025 a.push(format!(1026 "@returns {}",1027 if english {1028 "Result."1029 } else {1030 "返回结果。"1031 }1032 ));1033 a1034 };1035 let template = build(en).join("\n## ");1036 let mut bilingual = vec!["@lang zh-CN".into()];1037 bilingual.extend(build(false));1038 bilingual.push("@lang en".into());1039 bilingual.extend(build(true));1040 for (label, apply) in [1041 (1042 if en {1043 "Documentation template"1044 } else {1045 "文档模板"1046 },1047 template,1048 ),1049 (1050 if en {1051 "Bilingual documentation template"1052 } else {1053 "双语文档模板"1054 },1055 bilingual.join("\n## "),1056 ),1057 ] {1058 let mut o = option(label, "text", String::new(), apply, "Documentation");1059 o["from"] = json!(offset);1060 out.push(o)1061 }1062 } else {1063 for tag in ["lang", "param", "returns", "type", "example", "see"] {1064 let mut o = option(1065 &format!("@{tag}"),1066 "text",1067 String::new(),1068 format!("@{tag} "),1069 "Documentation",1070 );1071 if from > 0 && source.as_bytes()[from - 1] == b'@' {1072 o["from"] = json!(from - 1)1073 }1074 out.push(o)1075 }1076 }1077 return json!(out);1078 }1079 if tokens(source)1080 .iter()1081 .any(|t| t.kind == "comment" && t.from <= offset && t.to >= offset)1082 {1083 return json!([]);1084 }1085 let css_path =1086 uri.ends_with(".lcss") || uri.ends_with(".css") || css_region(source, offset).is_some();1087 if let Some((path_from, path_to, quoted)) = stylesheet_range(source, offset, css_path) {1088 return self.stylesheet_paths(uri, path_from, path_to, quoted);1089 }1090 if let Some(c) = context(source, offset) {1091 if c.name == "animate" && c.parameter == "name" {1092 let mut out = self1093 .stylesheet_completions(uri, "keyframe", from, to)1094 .as_array()1095 .unwrap()1096 .clone();1097 for name in ["laymesh-draw", "laymesh-reveal", "none"] {1098 out.push(option(name, "value", String::new(), name.into(), "LayMesh"));1099 }1100 return json!(out);1101 }1102 }1103 if let Some(c) = context(source, offset) {1104 let preset_name = c.receiver.is_empty()1105 && ["cmap", "palette"].contains(&c.name.as_str())1106 && (c.parameter == "name" || c.parameter.is_empty() && c.positional == 0)1107 && self1108 .resolve(uri, &c.name, offset, &mut BTreeSet::new())1109 .is_none();1110 if preset_name || c.parameter == "cmap" && self.callable(uri, offset, &c).is_some() {1111 let quoted = source[..from].trim_end().ends_with(['\'', '"']);1112 return json!(1113 laymesh_core::colormap::names(None, true)1114 .unwrap()1115 .into_iter()1116 .map(|name| {1117 option(1118 &name,1119 "value",1120 format!("Matplotlib {}", laymesh_core::colormap::VERSION),1121 if quoted {1122 name.clone()1123 } else {1124 json!(name).to_string()1125 },1126 "cmap",1127 )1128 })1129 .collect::<Vec<_>>()1130 );1131 }1132 }1133 let css = if uri.ends_with(".lcss") || uri.ends_with(".css") {1134 Some(0)1135 } else {1136 css_region(source, offset)1137 };1138 if let Some(start) = css {1139 let local = &source[start..offset];1140 if Regex::new(r"::[\w-]*$").unwrap().is_match(local) {1141 return json!(1142 [1143 "area",1144 "axis",1145 "axis-label",1146 "tick-label",1147 "legend",1148 "colorbar",1149 "marker",1150 "grid"1151 ]1152 .iter()1153 .map(|name| option(1154 name,1155 "keyword",1156 String::new(),1157 name.to_string(),1158 "LCSS part"1159 ))1160 .collect::<Vec<_>>()1161 );1162 }1163 if Regex::new(r"var\(\s*--[\w-]*$").unwrap().is_match(local) {1164 return self.stylesheet_completions(uri, "variable", from, to);1165 }1166 if Regex::new(r#"\[\s*class\s*(?:~=|=)\s*[\"'][^\"']*$"#)1167 .unwrap()1168 .is_match(local)1169 || Regex::new(r"\.[\w-]*$").unwrap().is_match(local)1170 {1171 return self.stylesheet_completions(uri, "class", from, to);1172 }1173 if local.rfind('{') > local.rfind('}') {1174 if let Some(cap) = Regex::new(r"([\w-]+)\s*:\s*([^;{}]*)$")1175 .unwrap()1176 .captures(local)1177 {1178 if &cap[1] == "animation-name"1179 || (&cap[1] == "animation" && !cap[2].contains(' '))1180 {1181 let mut names = self1182 .stylesheet_completions(uri, "keyframe", from, to)1183 .as_array()1184 .unwrap()1185 .clone();1186 names.push(option(1187 "none",1188 "keyword",1189 String::new(),1190 "none".into(),1191 "CSS animation",1192 ));1193 return json!(names);1194 }1195 let key = cap[1].replace('-', "_");1196 // Effect literals use the same constructor metadata as .lay.1197 if let Some(call) =1198 Regex::new(r"(shadow|glow|reflection|soft_edge|three_d)\([^)]*$")1199 .unwrap()1200 .captures(&cap[2])1201 {1202 let mut options = vec![];1203 if let Some(entry) = entries().iter().find(|a| a["name"] == &call[1]) {1204 for p in entry["parameters"].as_array().unwrap() {1205 let name = p["name"].as_str().unwrap();1206 options.push(option(1207 name,1208 "property",1209 parameter_doc(p, en, ""),1210 format!("{name}="),1211 "LCSS effect",1212 ));1213 }1214 }1215 return json!(options);1216 }1217 let metadata = api();1218 let p = metadata["cssProperties"]1219 .as_array()1220 .unwrap()1221 .iter()1222 .find(|p| p["name"] == key.replace('_', "-"));1223 let mut values = p.map(|p| strs(&p["values"])).unwrap_or_default();1224 values.push("var()".into());1225 if key == "effects" {1226 values.extend(1227 ["[shadow()]", "[glow()]", "[reflection()]", "[soft_edge()]"]1228 .map(str::to_string),1229 );1230 }1231 if key == "three_d" {1232 values.push("three_d()".into());1233 }1234 if key.starts_with("box_shadow") || key == "text_shadow" || key == "filter" {1235 values.extend(1236 ["currentColor", "calc()", "2mm", "drop-shadow()"].map(str::to_string),1237 );1238 }1239 if key.contains("fill") || key == "background" {1240 values.extend(1241 [1242 "none",1243 "linear-gradient()",1244 "radial-gradient()",1245 "hatch()",1246 "url()",1247 ]1248 .map(str::to_string),1249 )1250 }1251 return json!(1252 values1253 .iter()1254 .map(|v| option(v, "keyword", String::new(), v.clone(), ""))1255 .collect::<Vec<_>>()1256 );1257 }1258 let mut options = vec![];1259 for p in api()["cssProperties"].as_array().unwrap() {1260 let name = p["name"].as_str().unwrap();1261 options.push(option(1262 name,1263 "property",1264 parameter_doc(p, en, ""),1265 format!("{name}: "),1266 "LCSS",1267 ));1268 }1269 for (name, zh, en_text) in MOTION_PROPERTIES.iter().filter(|(name, _, _)| {1270 !api()["cssProperties"]1271 .as_array()1272 .unwrap()1273 .iter()1274 .any(|p| p["name"] == *name)1275 }) {1276 options.push(option(1277 name,1278 "property",1279 if en { en_text } else { zh }.to_string(),1280 format!("{name}: "),1281 "CSS animation",1282 ));1283 }1284 return json!(options);1285 }1286 return json!(1287 entries()1288 .iter()1289 .filter(|a| !a["name"].as_str().unwrap().contains('.'))1290 .map(|a| option(1291 a["name"].as_str().unwrap(),1292 "keyword",1293 desc(a, en).into(),1294 a["name"].as_str().unwrap().into(),1295 ""1296 ))1297 .collect::<Vec<_>>()1298 );1299 }1300 if Regex::new(r#"\b(?:class|classes)\s*=\s*["'][^"']*$"#)1301 .unwrap()1302 .is_match(before)1303 {1304 return self.stylesheet_completions(uri, "class", from, to);1305 }1306 if let Some(receiver) = receiver_before(source, from) {1307 let typ = self1308 .receiver_type(uri, &receiver, offset)1309 .unwrap_or_default();1310 let names = if receiver == "arrow"1311 && self1312 .resolve(uri, "arrow", offset, &mut BTreeSet::new())1313 .is_none()1314 {1315 entries()1316 .iter()1317 .filter(|e| e["namespaceConstructor"] == true)1318 .filter_map(|e| {1319 e["name"]1320 .as_str()?1321 .strip_prefix("arrow.")1322 .map(str::to_string)1323 })1324 .collect()1325 } else if ["plot", "polar_plot", "radar_plot"].contains(&typ.as_str()) {1326 entries()1327 .iter()1328 .filter_map(|e| {1329 e["name"]1330 .as_str()1331 .unwrap()1332 .strip_prefix("plot.")1333 .map(str::to_string)1334 })1335 .collect()1336 } else if let Some(members) = type_info(&typ)["members"].as_object() {1337 members1338 .keys()1339 .chain(type_info(&typ)["methods"].as_object().unwrap().keys())1340 .cloned()1341 .chain((typ == "instance").then_some("data".into()))1342 .chain((typ == "instance").then_some("axis".into()))1343 .collect()1344 } else {1345 [1346 "add",1347 "fuse",1348 "width",1349 "height",1350 "top_left",1351 "top_center",1352 "top_right",1353 "middle_left",1354 "center",1355 "middle_right",1356 "bottom_left",1357 "bottom_center",1358 "bottom_right",1359 "plot_center",1360 "data",1361 "axis",1362 ]1363 .iter()1364 .map(|s| s.to_string())1365 .chain((typ == "canvas").then_some("step".into()))1366 .collect::<Vec<_>>()1367 };1368 return json!(1369 names1370 .iter()1371 .map(|n| {1372 let c = Context {1373 name: n.clone(),1374 receiver: receiver.clone(),1375 ..Context::default()1376 };1377 let e = self.callable(uri, offset, &c);1378 let selected = geometry_member_type(&typ, n);1379 let detail = selected1380 .as_deref()1381 .or_else(|| e.as_ref().and_then(|e| e["returns"].as_str()))1382 .unwrap_or("");1383 option(1384 n,1385 if e.is_some() { "function" } else { "property" },1386 e.as_ref()1387 .and_then(|e| e["documentation"].as_str())1388 .unwrap_or("")1389 .into(),1390 if e.is_some() {1391 format!("{n}(")1392 } else {1393 n.clone()1394 },1395 detail,1396 )1397 })1398 .collect::<Vec<_>>()1399 );1400 }1401 let named = self.named(uri, offset);1402 let mut out: Vec<J> = named1403 .iter()1404 .map(|(name, s)| {1405 option(1406 name,1407 if s.kind == "function" {1408 "function"1409 } else {1410 "variable"1411 },1412 s.doc.markdown(en),1413 if s.kind == "function" {1414 format!("{name}(")1415 } else {1416 name.clone()1417 },1418 &self1419 .type_of(uri, name, offset)1420 .unwrap_or_else(|| s.typ.clone()),1421 )1422 })1423 .collect();1424 if let Some(c) = context(source, offset) {1425 if let Some(e) = self.callable(uri, offset, &c) {1426 let positional = e["parameters"]1427 .as_array()1428 .unwrap()1429 .iter()1430 .filter(|p| p["kind"] != "named")1431 .nth(c.positional)1432 .and_then(|p| p["name"].as_str())1433 .unwrap_or("");1434 let selected = if c.parameter.is_empty() {1435 positional1436 } else {1437 &c.parameter1438 };1439 if let Some(api) = entry(e["name"].as_str().unwrap()) {1440 if let Some(p) = api["parameters"]1441 .as_array()1442 .unwrap()1443 .iter()1444 .find(|p| p["name"] == selected)1445 {1446 if p["values"].is_array() {1447 let quoted = tokens(source)1448 .into_iter()1449 .find(|t| t.kind == "string" && t.from < offset && offset <= t.to);1450 let mut choices = vec![];1451 for value in strs(&p["values"]) {1452 if let Some(var) =1453 predefined_variables().iter().find(|v| v["value"] == value)1454 {1455 let name = var["name"].as_str().unwrap();1456 let mut o = option(1457 if quoted.is_some() { &value } else { name },1458 "variable",1459 variable_doc(name, &value),1460 if quoted.is_some() {1461 value.clone()1462 } else {1463 name.into()1464 },1465 "string",1466 );1467 if let Some(t) = "ed {1468 let quote = t.text.chars().next().unwrap();1469 o["from"] = json!(t.from + 1);1470 o["to"] =1471 json!(if t.text.len() > 1 && t.text.ends_with(quote) {1472 t.to - 11473 } else {1474 t.to1475 });1476 }1477 if quoted.is_some() || !named.iter().any(|(n, _)| n == name) {1478 choices.push(o);1479 }1480 } else {1481 // Some API enums are literal strings rather than1482 // predefined LAY variables (e.g. animation starts).1483 let mut o = option(1484 &value,1485 "value",1486 parameter_doc(p, en, e["name"].as_str().unwrap()),1487 if quoted.is_some() {1488 value.clone()1489 } else {1490 serde_json::to_string(&value).unwrap()1491 },1492 "string",1493 );1494 if let Some(t) = "ed {1495 let quote = t.text.chars().next().unwrap();1496 o["from"] = json!(t.from + 1);1497 o["to"] =1498 json!(if t.text.len() > 1 && t.text.ends_with(quote) {1499 t.to - 11500 } else {1501 t.to1502 });1503 }1504 choices.push(o);1505 }1506 }1507 if quoted.is_some() {1508 return json!(choices);1509 }1510 if selected == "anchor"1511 && p["values"]1512 .as_array()1513 .unwrap()1514 .iter()1515 .any(|v| v == "top_left")1516 {1517 choices.push(option(1518 "self",1519 "variable",1520 parameter_doc(p, en, "add"),1521 "self.".into(),1522 "instance selector",1523 ));1524 }1525 choices.append(&mut out);1526 out = choices;1527 if !c.parameter.is_empty() {1528 return json!(out);1529 }1530 }1531 }1532 }1533 if c.parameter.is_empty() {1534 let consumed: Vec<_> = e["parameters"]1535 .as_array()1536 .unwrap()1537 .iter()1538 .filter(|p| p["kind"] != "named")1539 .take(c.positional)1540 .map(|p| p["name"].as_str().unwrap().to_string())1541 .collect();1542 for p in e["parameters"].as_array().unwrap() {1543 let n = p["name"].as_str().unwrap();1544 if p["kind"] != "positional"1545 && !c.used.contains(&n.to_string())1546 && !consumed.contains(&n.to_string())1547 {1548 out.push(option(1549 n,1550 "property",1551 p["documentation"].as_str().unwrap_or("").into(),1552 format!("{n}="),1553 p["type"].as_str().unwrap_or(""),1554 ))1555 }1556 }1557 return json!(out);1558 }1559 if let Some(api) = entry(e["name"].as_str().unwrap()) {1560 if let Some(p) = api["parameters"]1561 .as_array()1562 .unwrap()1563 .iter()1564 .find(|p| p["name"] == c.parameter)1565 {1566 if p["unit"].as_str().is_some_and(|unit| unit != "none") {1567 out.extend(["mm", "cm", "in", "inch", "pt", "px", "auto"].iter().map(1568 |v| option(v, "keyword", parameter_doc(p, en, ""), (*v).into(), ""),1569 ));1570 return json!(out);1571 }1572 }1573 }1574 }1575 }1576 let shadowed: BTreeSet<&str> = named.iter().map(|(n, _)| n.as_str()).collect();1577 if !tokens(source)1578 .iter()1579 .any(|t| t.kind == "string" && t.from < offset && offset <= t.to)1580 {1581 for var in predefined_variables() {1582 let n = var["name"].as_str().unwrap();1583 if !shadowed.contains(n) {1584 out.push(option(1585 n,1586 "variable",1587 variable_doc(n, var["value"].as_str().unwrap()),1588 n.into(),1589 "string",1590 ));1591 }1592 }1593 } else {1594 return json!([]);1595 }1596 for a in entries() {1597 let n = a["name"].as_str().unwrap();1598 if !n.contains('.') && !shadowed.contains(n) {1599 out.push(option(1600 n,1601 "function",1602 builtin(n, en).unwrap()["documentation"]1603 .as_str()1604 .unwrap()1605 .into(),1606 format!("{n}("),1607 "",1608 ))1609 }1610 }1611 json!(out)1612 }1613 pub fn diagnostics(&self, uri: &str) -> J {1614 diagnostics(self, uri)1615 }1616 pub fn references(&self, uri: &str, offset: usize, include_declaration: bool) -> J {1617 let graph = self.binding_graph();1618 json!(1619 graph1620 .at(uri, offset)1621 .map(|o| graph1622 .related_references(&o.key, include_declaration)1623 .into_iter()1624 .map(|o| o.json())1625 .collect::<Vec<_>>())1626 .unwrap_or_default()1627 )1628 }1629 pub fn highlights(&self, uri: &str, offset: usize) -> J {1630 json!(1631 self.references(uri, offset, true)1632 .as_array()1633 .unwrap()1634 .iter()1635 .filter(|o| o["uri"] == uri)1636 .cloned()1637 .collect::<Vec<_>>()1638 )1639 }1640 pub fn prepare_rename(&self, uri: &str, offset: usize) -> J {1641 let graph = self.binding_graph();1642 let Some(o) = graph.at(uri, offset).filter(|o| graph.can_rename(&o.key)) else {1643 return J::Null;1644 };1645 json!({"from":o.from,"to":o.to,"placeholder":&self.source(uri)[o.from..o.to]})1646 }1647 pub fn rename(&self, uri: &str, offset: usize, new_name: &str) -> Result<J, String> {1648 self.binding_graph()1649 .rename(uri, offset, new_name)1650 .map(|edits| json!(edits))1651 }1652 pub fn query(&self, method: &str, uri: &str, offset: usize) -> J {1653 match method {1654 "completions" => self.completions(uri, offset),1655 "hover" => self.hover(uri, offset),1656 "signature" => self.signature(uri, offset),1657 "fileReferences" => file_references::references(self, uri),1658 "definition" => self.definition(uri, offset),1659 "references" => self.references(uri, offset, true),1660 "highlights" => self.highlights(uri, offset),1661 "prepareRename" => self.prepare_rename(uri, offset),1662 "diagnostics" => self.diagnostics(uri),1663 "colors" => self.document_colors(uri),1664 "stylesheetContent" => self.stylesheet_content(uri),1665 _ => J::Null,1666 }1667 }1668}1669pub fn css_region(source: &str, offset: usize) -> Option<usize> {1670 stylesheets::inline_ranges(source)1671 .into_iter()1672 .find(|(from, end)| offset >= *from && offset <= *end)1673 .map(|(from, _)| from)1674}1675pub fn byte_offset(source: &str, utf16: usize) -> usize {1676 let mut n = 0;1677 for (i, c) in source.char_indices() {1678 if n >= utf16 {1679 return i;1680 }1681 n += c.len_utf16()1682 }1683 source.len()1684}1685fn boundary(source: &str, byte: usize) -> usize {1686 let mut byte = byte.min(source.len());1687 while !source.is_char_boundary(byte) {1688 byte -= 1;1689 }1690 byte1691}1692pub fn utf16_offset(source: &str, byte: usize) -> usize {1693 source[..boundary(source, byte)].encode_utf16().count()1694}1695pub fn position(source: &str, byte: usize) -> J {1696 let before = &source[..boundary(source, byte)];1697 json!({"line":before.bytes().filter(|&b|b==b'\n').count(),"character":before.rsplit('\n').next().unwrap().encode_utf16().count()})1698}1699pub fn offset(source: &str, pos: &J) -> usize {1700 let line = pos["line"].as_u64().unwrap_or(0) as usize;1701 let col = pos["character"].as_u64().unwrap_or(0) as usize;1702 let start = source1703 .split_inclusive('\n')1704 .take(line)1705 .map(str::len)1706 .sum::<usize>()1707 .min(source.len());1708 start + byte_offset(source[start..].split('\n').next().unwrap(), col)1709}1710fn diagnostics(service: &LanguageService, uri: &str) -> J {1711 let source = service.source(uri);1712 let en = service.en();1713 let mut out = if uri.ends_with(".lcss") || uri.ends_with(".css") {1714 vec![]1715 } else {1716 index(uri, source, en).issues1717 };1718 out.extend(service.stylesheet_issues(uri));1719 let emit = |out: &mut Vec<J>,1720 from: usize,1721 to: usize,1722 code: &str,1723 message: String,1724 replacement: Option<&str>| {1725 let from = boundary(source, from);1726 let mut to = to.min(source.len());1727 while !source.is_char_boundary(to) {1728 to += 1;1729 }1730 let mut d = json!({"from":from,"to":to,"severity":"error","code":code,"message":message});1731 if let Some(r) = replacement {1732 d["replacement"] = json!(r)1733 }1734 out.push(d)1735 };1736 if uri.ends_with(".lcss") || uri.ends_with(".css") {1737 for d in laymesh_core::style::stylesheet_diagnostics(1738 source,1739 uri,1740 laymesh_core::Loc {1741 line: 1,1742 column: 1,1743 offset: 0,1744 },1745 ) {1746 out.push(json!({"from":d.loc.offset,"to":(d.loc.offset+1).min(source.len()),"severity":"warning","code":d.code,"message":d.message}));1747 }1748 return json!(out);1749 }1750 let stmts = match parser::parse(source, uri) {1751 Ok(v) => v,1752 Err(e) => {1753 emit(1754 &mut out,1755 e.loc.offset,1756 e.loc.offset + 1,1757 &e.code,1758 e.message,1759 None,1760 );1761 return json!(out);1762 }1763 };1764 let mut declared: BTreeSet<String> = entries()1765 .iter()1766 .map(|a| a["name"].as_str().unwrap().into())1767 .chain(1768 predefined_variables()1769 .iter()1770 .map(|v| v["name"].as_str().unwrap().to_string()),1771 )1772 .chain(["null", "self"].map(str::to_string))1773 .collect();1774 fn declare(stmts: &[Stmt], names: &mut BTreeSet<String>) {1775 for stmt in stmts {1776 match &stmt.kind {1777 StmtKind::Bind(n, _, _) => {1778 names.insert(n.clone());1779 }1780 StmtKind::Function(n, ps, b, _) => {1781 names.insert(n.clone());1782 for (p, _) in ps {1783 names.insert(p.clone());1784 }1785 declare(b, names)1786 }1787 StmtKind::Import(ns, _) => {1788 for (_, a) in ns {1789 names.insert(a.clone());1790 }1791 }1792 StmtKind::For(n, _, b) => {1793 names.extend(n.names());1794 declare(b, names)1795 }1796 StmtKind::While(_, b) => declare(b, names),1797 StmtKind::If(bs, other) => {1798 for (_, b) in bs {1799 declare(b, names)1800 }1801 declare(other, names)1802 }1803 _ => {}1804 }1805 }1806 }1807 declare(&stmts, &mut declared);1808 let inferred: BTreeMap<String, String> = index(uri, source, en)1809 .symbols1810 .into_iter()1811 .map(|s| (s.name, s.typ))1812 .collect();1813 fn walk(1814 e: &Expr,1815 out: &mut Vec<J>,1816 names: &BTreeSet<String>,1817 inferred: &BTreeMap<String, String>,1818 source: &str,1819 en: bool,1820 ) {1821 let mut report =1822 |from: usize, to: usize, code: &str, message: String, replacement: Option<&str>| {1823 let from = boundary(source, from);1824 let mut to = to.min(source.len());1825 while !source.is_char_boundary(to) {1826 to += 1;1827 }1828 let mut d =1829 json!({"from":from,"to":to,"severity":"error","code":code,"message":message});1830 if let Some(r) = replacement {1831 d["replacement"] = json!(r)1832 }1833 out.push(d)1834 };1835 match &e.kind {1836 ExprKind::Ref(ps) => {1837 if !names.contains(&ps[0]) {1838 report(1839 e.loc.offset,1840 e.loc.offset + ps[0].len(),1841 "E_NAME",1842 format!(1843 "{} {}",1844 if en {1845 "Unknown name"1846 } else {1847 "未定义名称"1848 },1849 ps[0]1850 ),1851 None,1852 )1853 }1854 }1855 ExprKind::Call(ps, args) => {1856 if ps == &["arrow"]1857 && !inferred.contains_key("arrow")1858 && args.iter().any(|(k, _)| {1859 k.as_deref()1860 .is_some_and(laymesh_core::migration::legacy_arrow_parameter)1861 })1862 {1863 let edit = laymesh_core::migration::arrow_edits(source)1864 .into_iter()1865 .find(|v| v.0 == e.loc.offset);1866 let to = edit.as_ref().map(|v| v.1).unwrap_or(e.loc.offset + 5);1867 report(1868 e.loc.offset,1869 to,1870 "E_API_MIGRATION",1871 if en {1872 "Legacy line-arrow parameters require line(..., end_head=head(...)); arrow now creates a filled shape"1873 } else {1874 "旧线条箭头参数使用 line(..., end_head=head(...));arrow 现在创建闭合形状"1875 }1876 .into(),1877 edit.as_ref().map(|v| v.2.as_str()),1878 );1879 } else if !names.contains(&ps[0]) {1880 report(1881 e.loc.offset,1882 e.loc.offset + ps[0].len(),1883 "E_NAME",1884 format!(1885 "{} {}",1886 if en {1887 "Unknown callable"1888 } else {1889 "未定义调用"1890 },1891 ps[0]1892 ),1893 None,1894 )1895 }1896 let last = ps.last().unwrap();1897 let typ = inferred.get(&ps[0]).map(String::as_str).unwrap_or("");1898 let surface =1899 if ps.len() == 2 && ps[0] == "arrow" && !inferred.contains_key("arrow") {1900 ps.join(".")1901 } else if ps.len() > 1 && ["plot", "polar_plot", "radar_plot"].contains(&typ) {1902 format!("plot.{last}")1903 } else if ps.len() > 11904 && typ == "instance"1905 && ["data", "axis"].contains(&last.as_str())1906 {1907 format!("instance.{last}")1908 } else if ps.len() > 1 && ["dict", "table", "cmap", "document"].contains(&typ) {1909 format!("{}.{last}", if typ == "table" { "dict" } else { typ })1910 } else if ps.len() > 1 {1911 geometry_surface(last).unwrap_or_else(|| last.clone())1912 } else {1913 last.clone()1914 };1915 if let Some(api) =1916 entry(&surface).filter(|_| ps[0] != "arrow" || !inferred.contains_key("arrow"))1917 {1918 for (n, v) in args {1919 if let Some(n) = n {1920 let before = &source[e.loc.offset..v.loc.offset.min(source.len())];1921 let re = Regex::new(&format!(r"\b{}\s*=", regex::escape(n))).unwrap();1922 let from = re1923 .find_iter(before)1924 .last()1925 .map(|m| e.loc.offset + m.start())1926 .unwrap_or(v.loc.offset);1927 let rename = match n.as_str() {1928 "font" => Some("font_family"),1929 "weight" => Some("font_weight"),1930 "italic" => Some("font_style"),1931 "stroke" => Some("border_color"),1932 "stroke_width" => Some("border_width"),1933 "classes" => Some("class"),1934 "width" | "height" => Some("size"),1935 _ => None,1936 };1937 if let Some(rename) = rename {1938 report(1939 from,1940 from + n.len(),1941 "E_API_MIGRATION",1942 format!("{n} → {rename}"),1943 Some(rename),1944 );1945 continue;1946 }1947 let parameter = api["parameters"]1948 .as_array()1949 .unwrap()1950 .iter()1951 .find(|p| p["name"] == *n);1952 if parameter.is_none() {1953 report(1954 from,1955 from + n.len(),1956 "E_ARG",1957 format!(1958 "{surface}: {} {n}",1959 if en {1960 "unknown parameter"1961 } else {1962 "不支持参数"1963 }1964 ),1965 None,1966 );1967 continue;1968 }1969 let p = parameter.unwrap();1970 fn angle_in_length(v: &Expr) -> bool {1971 match &v.kind {1972 ExprKind::Number(_, unit) => unit == "deg" || unit == "rad",1973 ExprKind::List(values) => values.iter().any(angle_in_length),1974 _ => false,1975 }1976 }1977 if (p["unit"] == "geometry" || p["unit"] == "pt") && angle_in_length(v)1978 {1979 report(1980 v.loc.offset,1981 v.loc.offset + 1,1982 "E_UNIT",1983 if en {1984 "Expected a length, received an angle"1985 } else {1986 "需要长度,不能使用角度"1987 }1988 .into(),1989 None,1990 )1991 }1992 fn literal_number(v: &Expr) -> Option<f64> {1993 match &v.kind {1994 ExprKind::Number(value, _) => Some(*value),1995 ExprKind::Unary(op, value) if op == "-" => {1996 literal_number(value).map(|v| -v)1997 }1998 ExprKind::Unary(op, value) if op == "+" => {1999 literal_number(value)2000 }2001 _ => None,2002 }2003 }2004 if (["blur", "spread", "depth", "text_stroke_width"]2005 .contains(&n.as_str())2006 && literal_number(v).is_some_and(|v| v < 0.))2007 || (n == "wavelength" && literal_number(v).is_some_and(|v| v <= 0.))2008 {2009 report(2010 v.loc.offset,2011 v.loc.offset + 1,2012 "E_EFFECT",2013 if n == "wavelength" {2014 "wavelength must be positive"2015 } else {2016 "Effect length must be nonnegative"2017 }2018 .into(),2019 None,2020 );2021 }2022 if n == "effects"2023 && matches!(2024 v.kind,2025 ExprKind::Call(..)2026 | ExprKind::Number(..)2027 | ExprKind::String(..)2028 | ExprKind::Bool(_)2029 )2030 {2031 report(2032 v.loc.offset,2033 v.loc.offset + 1,2034 "E_EFFECT",2035 "effects requires a list of shadow(...), glow(...), reflection(...) or soft_edge(...)".into(),2036 None,2037 );2038 }2039 if n == "font_family"2040 && (matches!(v.kind, ExprKind::Number(..) | ExprKind::Bool(_))2041 || matches!(&v.kind, ExprKind::List(values) if values.iter().any(|v| matches!(v.kind, ExprKind::Number(..) | ExprKind::Bool(_)))))2042 {2043 report(2044 v.loc.offset,2045 v.loc.offset + 1,2046 "E_TYPE",2047 if en {2048 "Expected a font name or ordered string list"2049 } else {2050 "font_family 需要字体名称或有序字符串列表"2051 }2052 .into(),2053 None,2054 )2055 }2056 if matches!(v.kind, ExprKind::Bool(_))2057 && (p["unit"] == "geometry" || p["unit"] == "pt")2058 {2059 report(2060 v.loc.offset,2061 v.loc.offset + 1,2062 "E_TYPE",2063 if en {2064 "Expected a physical length"2065 } else {2066 "需要物理长度"2067 }2068 .into(),2069 None,2070 );2071 }2072 if n == "size" && matches!(&v.kind,ExprKind::List(xs)if xs.len()!=2) {2073 report(2074 v.loc.offset,2075 v.loc.offset + 1,2076 "E_TYPE",2077 "size requires two dimensions".into(),2078 None,2079 )2080 }2081 if n == "opacity"2082 && matches!(&v.kind,ExprKind::Number(n,u)if !u.is_empty()||*n<0.||*n>1.)2083 {2084 report(2085 v.loc.offset,2086 v.loc.offset + 1,2087 "E_VALUE",2088 "opacity: 0–1".into(),2089 None,2090 )2091 }2092 if let ExprKind::Ref(parts) = &v.kind {2093 if parts.len() == 1 && !inferred.contains_key(&parts[0]) {2094 if let Some(value) = predefined_value(&parts[0]) {2095 if p["values"].is_array()2096 && !strs(&p["values"]).contains(&value.to_string())2097 {2098 report(2099 v.loc.offset,2100 v.loc.offset + parts[0].len(),2101 "E_VALUE",2102 format!("{n}: {}", strs(&p["values"]).join(" / ")),2103 None,2104 );2105 }2106 }2107 }2108 }2109 if let ExprKind::String(s, _, _) = &v.kind {2110 if matches!(p["type"].as_str(), Some("color" | "paint"))2111 && laymesh_core::color::Color::parse(s).is_err()2112 {2113 report(v.loc.offset,v.loc.offset+1,"E_COLOR",if en {"Invalid color; use HEX, RGB, HSV or OKLCH with valid channels"} else {"无效颜色;使用通道合法的 HEX、RGB、HSV 或 OKLCH"}.into(),None);2114 }2115 if p["values"].is_array()2116 && !strs(&p["values"]).contains(s)2117 && n != "scale"2118 && n != "style"2119 {2120 report(2121 v.loc.offset,2122 v.loc.offset + 1,2123 "E_VALUE",2124 format!("{n}: {}", strs(&p["values"]).join(" / ")),2125 None,2126 )2127 }2128 }2129 }2130 }2131 }2132 fn number(e: &Expr) -> bool {2133 match &e.kind {2134 ExprKind::Number(..) => true,2135 ExprKind::Unary(op, v) if op == "-" || op == "+" => number(v),2136 _ => false,2137 }2138 }2139 if ps.len() == 12140 && ["rgb", "hsv", "oklch"].contains(&last.as_str())2141 && !inferred.contains_key(last)2142 && args.len() >= 32143 && args.iter().all(|(_, v)| number(v))2144 && laymesh_core::color::constant_expression(e).is_none()2145 {2146 report(e.loc.offset,e.loc.offset+last.len(),"E_COLOR",if en {"Invalid color channels: RGB 0–255, HSV S/V and OKLCH L 0–1, C ≥ 0, alpha 0–1; angle units only on hue"} else {"颜色通道无效:RGB 0–255,HSV S/V 和 OKLCH L 0–1,C ≥ 0,alpha 0–1;仅色相接受角度单位"}.into(),None);2147 }2148 if surface == "line" {2149 let keys = args2150 .iter()2151 .filter_map(|(k, _)| k.as_deref())2152 .collect::<Vec<_>>();2153 if (keys.contains(&"dx") && !keys.contains(&"dy"))2154 || (keys.contains(&"dy") && !keys.contains(&"dx"))2155 || (keys.contains(&"angle") && !keys.contains(&"length"))2156 {2157 report(2158 e.loc.offset,2159 e.loc.offset + 4,2160 "E_ARG",2161 if en {2162 "Geometry must specify both dx/dy, or length with optional angle"2163 } else {2164 "几何定义需要完整的 dx/dy,或 length 及可选 angle"2165 }2166 .into(),2167 None,2168 );2169 }2170 if (keys.contains(&"length") || keys.contains(&"angle"))2171 && (keys.contains(&"dx") || keys.contains(&"dy"))2172 {2173 report(2174 e.loc.offset,2175 e.loc.offset + 4,2176 "E_ARG",2177 if en {2178 "length/angle and dx/dy are mutually exclusive"2179 } else {2180 "length/angle 与 dx/dy 互斥"2181 }2182 .into(),2183 None,2184 );2185 }2186 if !keys.contains(&"angle")2187 && args.iter().any(|(k, v)| {2188 k.as_deref() == Some("length")2189 && matches!(&v.kind,ExprKind::Number(n,_)if *n==0.)2190 })2191 {2192 report(2193 e.loc.offset,2194 e.loc.offset + 4,2195 "E_ANCHOR_DIRECTION",2196 if en {2197 "Zero-length line requires an explicit angle"2198 } else {2199 "零长度线需要显式 angle"2200 }2201 .into(),2202 None,2203 );2204 }2205 }2206 for (_, v) in args {2207 walk(v, out, names, inferred, source, en)2208 }2209 }2210 ExprKind::Dict(es) => {2211 for (key, value) in es {2212 walk(key, out, names, inferred, source, en);2213 walk(value, out, names, inferred, source, en);2214 }2215 }2216 ExprKind::List(vs) => {2217 for v in vs {2218 walk(v, out, names, inferred, source, en)2219 }2220 }2221 ExprKind::Member(receiver, _) => walk(receiver, out, names, inferred, source, en),2222 ExprKind::Method(receiver, name, args) => {2223 walk(receiver, out, names, inferred, source, en);2224 let call = Expr {2225 identity: 0,2226 site: 0,2227 loc: e.loc,2228 kind: ExprKind::Call(vec!["self".into(), name.clone()], args.clone()),2229 };2230 walk(&call, out, names, inferred, source, en);2231 }2232 ExprKind::Index(a, b) | ExprKind::Binary(_, a, b) => {2233 walk(a, out, names, inferred, source, en);2234 walk(b, out, names, inferred, source, en)2235 }2236 ExprKind::Unary(_, v) => walk(v, out, names, inferred, source, en),2237 _ => {}2238 }2239 }2240 fn statements(2241 stmts: &[Stmt],2242 out: &mut Vec<J>,2243 names: &BTreeSet<String>,2244 inferred: &BTreeMap<String, String>,2245 source: &str,2246 en: bool,2247 ) {2248 for s in stmts {2249 match &s.kind {2250 StmtKind::Bind(_, e, _) | StmtKind::Expr(e) | StmtKind::Return(e) => {2251 walk(e, out, names, inferred, source, en)2252 }2253 StmtKind::SetIndex(target, value) => {2254 walk(target, out, names, inferred, source, en);2255 walk(value, out, names, inferred, source, en);2256 }2257 StmtKind::Function(_, ps, b, _) => {2258 for (_, e) in ps {2259 if let Some(e) = e {2260 walk(e, out, names, inferred, source, en)2261 }2262 }2263 statements(b, out, names, inferred, source, en)2264 }2265 StmtKind::If(bs, other) => {2266 for (e, b) in bs {2267 walk(e, out, names, inferred, source, en);2268 statements(b, out, names, inferred, source, en)2269 }2270 statements(other, out, names, inferred, source, en)2271 }2272 StmtKind::For(_, e, b) | StmtKind::While(e, b) => {2273 walk(e, out, names, inferred, source, en);2274 statements(b, out, names, inferred, source, en)2275 }2276 StmtKind::Style(css) => {2277 for d in laymesh_core::style::stylesheet_diagnostics(css, "", s.loc) {2278 out.push(json!({"from":d.loc.offset.min(source.len()),"to":(d.loc.offset+1).min(source.len()),"severity":"warning","code":d.code,"message":d.message}));2279 }2280 }2281 _ => {}2282 }2283 }2284 }2285 statements(&stmts, &mut out, &declared, &inferred, source, en);2286 out.extend(connections::diagnostics(service, uri, &stmts));2287 json!(out)2288}2289 2290const MOTION_PROPERTIES: &[(&str, &str, &str)] = &[2291 (2292 "animation",2293 "CSS 动画简写:名称 时长 缓动 延迟 次数 方向 填充 状态",2294 "CSS animation shorthand: name duration easing delay count direction fill state",2295 ),2296 (2297 "animation-name",2298 "@keyframes 名称;默认 none",2299 "Keyframe names; initial none",2300 ),2301 (2302 "animation-duration",2303 "单次动画时长;默认 0s",2304 "Iteration duration; initial 0s",2305 ),2306 (2307 "animation-delay",2308 "动画延迟,支持负值;默认 0s",2309 "Delay, including negatives; initial 0s",2310 ),2311 (2312 "animation-timing-function",2313 "ease/linear/cubic-bezier()/steps();steps() 是阶梯缓动",2314 "ease/linear/cubic-bezier()/steps(); steps() is stepped easing",2315 ),2316 (2317 "animation-iteration-count",2318 "次数或 infinite;默认 1",2319 "Iteration count or infinite; initial 1",2320 ),2321 (2322 "animation-direction",2323 "normal/reverse/alternate/alternate-reverse",2324 "normal/reverse/alternate/alternate-reverse",2325 ),2326 (2327 "animation-fill-mode",2328 "none/forwards/backwards/both;默认 none",2329 "none/forwards/backwards/both; initial none",2330 ),2331 ("animation-play-state", "running/paused", "running/paused"),2332 (2333 "transform",2334 "标准 CSS 2D/3D 变换;px 使用画布 layout_dpi(默认 96),与静态样式一致",2335 "CSS 2D/3D transforms; px uses canvas layout_dpi (default 96), shared with static styles",2336 ),2337 (2338 "transform-origin",2339 "变换原点;百分比基于布局框",2340 "Transform origin; percentages use the layout box",2341 ),2342 (2343 "visibility",2344 "visible/hidden/collapse",2345 "visible/hidden/collapse",2346 ),2347 ("backface-visibility", "visible/hidden", "visible/hidden"),2348 (2349 "-laymesh-draw",2350 "非标准扩展:开放描线进度 0–1",2351 "Nonstandard extension: open stroke progress 0–1",2352 ),2353 (2354 "-laymesh-reveal",2355 "非标准扩展:区域揭示进度 0–1",2356 "Nonstandard extension: area reveal progress 0–1",2357 ),2358];