>,
+ _translations_type: std::marker::PhantomData,
}
-fn get_key(module_idx: usize, translation_idx: usize) -> &'static str {
- KEYS_BY_MODULE
- .get(module_idx)
- .and_then(|translations| translations.get(translation_idx))
- .cloned()
- .unwrap_or("invalid-module-or-translation-index")
-}
+impl I18n {
+ fn get_key(module_idx: usize, translation_idx: usize) -> &'static str {
+ P::KEYS_BY_MODULE
+ .get(module_idx)
+ .and_then(|translations| translations.get(translation_idx))
+ .cloned()
+ .unwrap_or("invalid-module-or-translation-index")
+ }
+
+ fn get_modules(langs: &[LanguageIdentifier], desired_modules: &[String]) -> Vec {
+ langs
+ .iter()
+ .map(|lang| {
+ let mut buf = String::new();
+ let lang_name = remapped_lang_name(lang);
+ if let Some(strings) = P::STRINGS.get(lang_name) {
+ if desired_modules.is_empty() {
+ // empty list, provide all modules
+ for value in strings.values() {
+ buf.push_str(value)
+ }
+ } else {
+ for module_name in desired_modules {
+ if let Some(text) = strings.get(module_name.as_str()) {
+ buf.push_str(text);
+ }
+ }
+ }
+ }
+ buf
+ })
+ .collect()
+ }
+
+ /// This temporarily behaves like the older code; in the future we could
+ /// either access each &str separately, or load them on demand.
+ fn ftl_localized_text(lang: &LanguageIdentifier) -> Option {
+ let lang = remapped_lang_name(lang);
+ if let Some(module) = P::STRINGS.get(lang) {
+ let mut text = String::new();
+ for module_text in module.values() {
+ text.push_str(module_text)
+ }
+ Some(text)
+ } else {
+ None
+ }
+ }
-impl I18n {
pub fn template_only() -> Self {
Self::new::<&str>(&[])
}
@@ -225,7 +274,7 @@ impl I18n {
let mut output_langs = vec![];
for lang in input_langs {
// if the language is bundled in the binary
- if let Some(text) = ftl_localized_text(&lang).or_else(|| {
+ if let Some(text) = Self::ftl_localized_text(&lang).or_else(|| {
// when testing, allow missing translations
if cfg!(test) {
Some(String::new())
@@ -244,7 +293,7 @@ impl I18n {
// add English templates
let template_lang = "en-US".parse().unwrap();
- let template_text = ftl_localized_text(&template_lang).unwrap();
+ let template_text = Self::ftl_localized_text(&template_lang).unwrap();
let template_bundle = get_bundle_with_extra(&template_text, None).unwrap();
bundles.push(template_bundle);
output_langs.push(template_lang);
@@ -261,6 +310,7 @@ impl I18n {
bundles,
langs: output_langs,
})),
+ _translations_type: PhantomData,
}
}
@@ -270,7 +320,7 @@ impl I18n {
message_index: usize,
args: FluentArgs,
) -> String {
- let key = get_key(module_index, message_index);
+ let key = Self::get_key(module_index, message_index);
self.translate(key, Some(args)).into()
}
@@ -305,7 +355,7 @@ impl I18n {
/// implementation.
pub fn resources_for_js(&self, desired_modules: &[String]) -> ResourcesForJavascript {
let inner = self.inner.lock().unwrap();
- let resources = get_modules(&inner.langs, desired_modules);
+ let resources = Self::get_modules(&inner.langs, desired_modules);
ResourcesForJavascript {
langs: inner.langs.iter().map(ToString::to_string).collect(),
resources,
@@ -313,47 +363,6 @@ impl I18n {
}
}
-fn get_modules(langs: &[LanguageIdentifier], desired_modules: &[String]) -> Vec {
- langs
- .iter()
- .cloned()
- .map(|lang| {
- let mut buf = String::new();
- let lang_name = remapped_lang_name(&lang);
- if let Some(strings) = STRINGS.get(lang_name) {
- if desired_modules.is_empty() {
- // empty list, provide all modules
- for value in strings.values() {
- buf.push_str(value)
- }
- } else {
- for module_name in desired_modules {
- if let Some(text) = strings.get(module_name.as_str()) {
- buf.push_str(text);
- }
- }
- }
- }
- buf
- })
- .collect()
-}
-
-/// This temporarily behaves like the older code; in the future we could either
-/// access each &str separately, or load them on demand.
-fn ftl_localized_text(lang: &LanguageIdentifier) -> Option {
- let lang = remapped_lang_name(lang);
- if let Some(module) = STRINGS.get(lang) {
- let mut text = String::new();
- for module_text in module.values() {
- text.push_str(module_text)
- }
- Some(text)
- } else {
- None
- }
-}
-
struct I18nInner {
// bundles in preferred language order, with template English as the
// last element
@@ -490,7 +499,7 @@ mod test {
#[test]
fn i18n() {
// English template
- let tr = I18n::new(&["zz"]);
+ let tr = I18n::::new(&["zz"]);
assert_eq!(tr.translate("valid-key", None), "a valid key");
assert_eq!(tr.translate("invalid-key", None), "invalid-key");
@@ -513,7 +522,7 @@ mod test {
);
// Another language
- let tr = I18n::new(&["ja_JP"]);
+ let tr = I18n::::new(&["ja_JP"]);
assert_eq!(tr.translate("valid-key", None), "キー");
assert_eq!(tr.translate("only-in-english", None), "not translated");
assert_eq!(tr.translate("invalid-key", None), "invalid-key");
@@ -524,7 +533,7 @@ mod test {
);
// Decimal separator
- let tr = I18n::new(&["pl-PL"]);
+ let tr = I18n::::new(&["pl-PL"]);
// Polish will use a comma if the string is translated
assert_eq!(
tr.translate("one-arg-key", Some(tr_args!["one"=>2.07])),
diff --git a/rslib/i18n/typescript.rs b/rslib/i18n/typescript.rs
index ce30048e24e..0f483cb586a 100644
--- a/rslib/i18n/typescript.rs
+++ b/rslib/i18n/typescript.rs
@@ -1,7 +1,6 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
-use std::env;
use std::fmt::Write;
use std::path::PathBuf;
@@ -22,7 +21,7 @@ pub fn write_ts_interface(modules: &[Module]) -> Result<()> {
render_module_map(modules, &mut ts_out);
render_methods(modules, &mut ts_out);
- if let Ok(path) = env::var("STRINGS_TS") {
+ if let Some(path) = option_env!("STRINGS_TS") {
let path = PathBuf::from(path);
create_dir_all(path.parent().unwrap())?;
write_file_if_changed(path, ts_out)?;
diff --git a/rslib/i18n/write_strings.rs b/rslib/i18n/write_strings.rs
index 33905d98fd8..db31be2b78d 100644
--- a/rslib/i18n/write_strings.rs
+++ b/rslib/i18n/write_strings.rs
@@ -15,7 +15,7 @@ use crate::extract::VariableKind;
use crate::gather::TranslationsByFile;
use crate::gather::TranslationsByLang;
-pub fn write_strings(map: &TranslationsByLang, modules: &[Module]) {
+pub fn write_strings(map: &TranslationsByLang, modules: &[Module], out_fn: &str, tag: &str) {
let mut buf = String::new();
// lang->module map
@@ -25,23 +25,25 @@ pub fn write_strings(map: &TranslationsByLang, modules: &[Module]) {
// ordered list of translations by module
write_translation_key_index(modules, &mut buf);
// methods to generate messages
- write_methods(modules, &mut buf);
+ write_methods(modules, &mut buf, tag);
let dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
- let path = dir.join("strings.rs");
+ let path = dir.join(out_fn);
fs::write(path, buf).unwrap();
}
-fn write_methods(modules: &[Module], buf: &mut String) {
+fn write_methods(modules: &[Module], buf: &mut String, tag: &str) {
buf.push_str(
r#"
-use crate::{I18n,Number};
+#[allow(unused_imports)]
+use crate::{I18n,Number,Translations};
+#[allow(unused_imports)]
use fluent::{FluentValue, FluentArgs};
use std::borrow::Cow;
-impl I18n {
"#,
);
+ writeln!(buf, "impl I18n<{tag}> {{").unwrap();
for module in modules {
for translation in &module.translations {
let func = translation.key.to_snake_case();
@@ -142,7 +144,7 @@ fn write_translation_key_index(modules: &[Module], buf: &mut String) {
writeln!(
buf,
- "pub(crate) const KEYS_BY_MODULE: [&[&str]; {count}] = [",
+ "pub(crate) const _KEYS_BY_MODULE: [&[&str]; {count}] = [",
count = modules.len(),
)
.unwrap();
@@ -162,7 +164,7 @@ fn write_translation_key_index(modules: &[Module], buf: &mut String) {
fn write_lang_map(map: &TranslationsByLang, buf: &mut String) {
buf.push_str(
"
-pub(crate) const STRINGS: phf::Map<&str, &phf::Map<&str, &str>> = phf::phf_map! {
+pub(crate) const _STRINGS: phf::Map<&str, &phf::Map<&str, &str>> = phf::phf_map! {
",
);
diff --git a/rslib/io/src/lib.rs b/rslib/io/src/lib.rs
index cb44467e613..0fd85e49008 100644
--- a/rslib/io/src/lib.rs
+++ b/rslib/io/src/lib.rs
@@ -335,6 +335,15 @@ pub fn write_file_if_changed(path: impl AsRef, contents: impl AsRef<[u8]>)
.map(|existing| existing != contents)
.unwrap_or(true)
};
+
+ match std::env::var("CARGO_PKG_NAME") {
+ Ok(pkg) if pkg == "anki_proto" || pkg == "anki_i18n" => {
+ // at comptime for the proto/i18n crates, register implicit output as input
+ println!("cargo:rerun-if-changed={}", path.to_str().unwrap());
+ }
+ _ => {}
+ }
+
if changed {
write_file(path, contents)?;
Ok(true)
diff --git a/rslib/proto/python.rs b/rslib/proto/python.rs
index a5adb417956..5c245de1d0d 100644
--- a/rslib/proto/python.rs
+++ b/rslib/proto/python.rs
@@ -22,7 +22,7 @@ pub(crate) fn write_python_interface(services: &[BackendService]) -> Result<()>
write_header(&mut out)?;
for service in services {
- if service.name == "BackendAnkidroidService" {
+ if ["BackendAnkidroidService", "BackendFrontendService"].contains(&service.name.as_str()) {
continue;
}
for method in service.all_methods() {
diff --git a/rslib/src/cloze.rs b/rslib/src/cloze.rs
index 027c14c0c04..70a5d1703a8 100644
--- a/rslib/src/cloze.rs
+++ b/rslib/src/cloze.rs
@@ -10,6 +10,7 @@ use std::sync::LazyLock;
use anki_proto::image_occlusion::get_image_occlusion_note_response::ImageOcclusion;
use anki_proto::image_occlusion::get_image_occlusion_note_response::ImageOcclusionShape;
use htmlescape::encode_attribute;
+use itertools::Itertools;
use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::bytes::complete::take_while;
@@ -26,7 +27,7 @@ use crate::template::RenderContext;
use crate::text::strip_html_preserving_entities;
static CLOZE: LazyLock =
- LazyLock::new(|| Regex::new(r"(?s)\{\{c\d+::(.*?)(::.*?)?\}\}").unwrap());
+ LazyLock::new(|| Regex::new(r"(?s)\{\{c[\d,]+::(.*?)(::.*?)?\}\}").unwrap());
static MATHJAX: LazyLock = LazyLock::new(|| {
Regex::new(
@@ -48,7 +49,7 @@ mod mathjax_caps {
#[derive(Debug)]
enum Token<'a> {
// The parameter is the cloze number as is appears in the field content.
- OpenCloze(u16),
+ OpenCloze(Vec),
Text(&'a str),
CloseCloze,
}
@@ -58,21 +59,24 @@ fn tokenize(mut text: &str) -> impl Iterator- > {
fn open_cloze(text: &str) -> IResult<&str, Token<'_>> {
// opening brackets and 'c'
let (text, _opening_brackets_and_c) = tag("{{c")(text)?;
- // following number
- let (text, digits) = take_while(|c: char| c.is_ascii_digit())(text)?;
- let digits: u16 = match digits.parse() {
- Ok(digits) => digits,
- Err(_) => {
- // not a valid number; fail to recognize
- return Err(nom::Err::Error(nom::error::make_error(
- text,
- nom::error::ErrorKind::Digit,
- )));
- }
- };
+ // following comma-seperated numbers
+ let (text, ordinals) = take_while(|c: char| c.is_ascii_digit() || c == ',')(text)?;
+ let ordinals: Vec = ordinals
+ .split(',')
+ .filter_map(|s| s.parse().ok())
+ .collect::>() // deduplicate
+ .into_iter()
+ .sorted() // set conversion can de-order
+ .collect();
+ if ordinals.is_empty() {
+ return Err(nom::Err::Error(nom::error::make_error(
+ text,
+ nom::error::ErrorKind::Digit,
+ )));
+ }
// ::
let (text, _colons) = tag("::")(text)?;
- Ok((text, Token::OpenCloze(digits)))
+ Ok((text, Token::OpenCloze(ordinals)))
}
fn close_cloze(text: &str) -> IResult<&str, Token<'_>> {
@@ -121,11 +125,20 @@ enum TextOrCloze<'a> {
#[derive(Debug)]
struct ExtractedCloze<'a> {
// `ordinal` is the cloze number as is appears in the field content.
- ordinal: u16,
+ ordinals: Vec,
nodes: Vec>,
hint: Option<&'a str>,
}
+/// Generate a string representation of the ordinals for HTML
+fn ordinals_str(ordinals: &[u16]) -> String {
+ ordinals
+ .iter()
+ .map(|o| o.to_string())
+ .collect::>()
+ .join(",")
+}
+
impl ExtractedCloze<'_> {
/// Return the cloze's hint, or "..." if none was provided.
fn hint(&self) -> &str {
@@ -151,6 +164,11 @@ impl ExtractedCloze<'_> {
buf.into()
}
+ /// Checks if this cloze is active for a given ordinal
+ fn contains_ordinal(&self, ordinal: u16) -> bool {
+ self.ordinals.contains(&ordinal)
+ }
+
/// If cloze starts with image-occlusion:, return the text following that.
fn image_occlusion(&self) -> Option<&str> {
let TextOrCloze::Text(text) = self.nodes.first()? else {
@@ -165,10 +183,10 @@ fn parse_text_with_clozes(text: &str) -> Vec> {
let mut output = vec![];
for token in tokenize(text) {
match token {
- Token::OpenCloze(ordinal) => {
+ Token::OpenCloze(ordinals) => {
if open_clozes.len() < 10 {
open_clozes.push(ExtractedCloze {
- ordinal,
+ ordinals,
nodes: Vec::with_capacity(1), // common case
hint: None,
})
@@ -214,7 +232,7 @@ fn reveal_cloze_text_in_nodes(
output: &mut Vec,
) {
if let TextOrCloze::Cloze(cloze) = node {
- if cloze.ordinal == cloze_ord {
+ if cloze.contains_ordinal(cloze_ord) {
if question {
output.push(cloze.hint().into())
} else {
@@ -234,14 +252,15 @@ fn reveal_cloze(
active_cloze_found_in_text: &mut bool,
buf: &mut String,
) {
- let active = cloze.ordinal == cloze_ord;
+ let active = cloze.contains_ordinal(cloze_ord);
*active_cloze_found_in_text |= active;
+
if let Some(image_occlusion_text) = cloze.image_occlusion() {
buf.push_str(&render_image_occlusion(
image_occlusion_text,
question,
active,
- cloze.ordinal,
+ &cloze.ordinals,
));
return;
}
@@ -265,7 +284,7 @@ fn reveal_cloze(
buf,
r#"[{}]"#,
encode_attribute(&content_buf),
- cloze.ordinal,
+ ordinals_str(&cloze.ordinals),
cloze.hint()
)
.unwrap();
@@ -274,7 +293,7 @@ fn reveal_cloze(
write!(
buf,
r#""#,
- cloze.ordinal
+ ordinals_str(&cloze.ordinals)
)
.unwrap();
for node in &cloze.nodes {
@@ -292,7 +311,7 @@ fn reveal_cloze(
write!(
buf,
r#""#,
- cloze.ordinal
+ ordinals_str(&cloze.ordinals)
)
.unwrap();
for node in &cloze.nodes {
@@ -308,23 +327,28 @@ fn reveal_cloze(
}
}
-fn render_image_occlusion(text: &str, question_side: bool, active: bool, ordinal: u16) -> String {
- if (question_side && active) || ordinal == 0 {
+fn render_image_occlusion(
+ text: &str,
+ question_side: bool,
+ active: bool,
+ ordinals: &[u16],
+) -> String {
+ if (question_side && active) || ordinals.contains(&0) {
format!(
r#""#,
- ordinal,
+ ordinals_str(ordinals),
&get_image_cloze_data(text)
)
} else if !active {
format!(
r#""#,
- ordinal,
+ ordinals_str(ordinals),
&get_image_cloze_data(text)
)
} else if !question_side && active {
format!(
r#""#,
- ordinal,
+ ordinals_str(ordinals),
&get_image_cloze_data(text)
)
} else {
@@ -338,7 +362,10 @@ pub fn parse_image_occlusions(text: &str) -> Vec {
if let TextOrCloze::Cloze(cloze) = node {
if cloze.image_occlusion().is_some() {
if let Some(shape) = parse_image_cloze(cloze.image_occlusion().unwrap()) {
- occlusions.entry(cloze.ordinal).or_default().push(shape);
+ // Associate this occlusion with all ordinals in this cloze
+ for &ordinal in &cloze.ordinals {
+ occlusions.entry(ordinal).or_default().push(shape.clone());
+ }
}
}
}
@@ -420,7 +447,7 @@ pub fn expand_clozes_to_reveal_latex(text: &str) -> String {
pub(crate) fn contains_cloze(text: &str) -> bool {
parse_text_with_clozes(text)
.iter()
- .any(|node| matches!(node, TextOrCloze::Cloze(e) if e.ordinal != 0))
+ .any(|node| matches!(node, TextOrCloze::Cloze(e) if e.ordinals.iter().any(|&o| o != 0)))
}
/// Returns the set of cloze number as they appear in the fields's content.
@@ -433,10 +460,12 @@ pub fn cloze_numbers_in_string(html: &str) -> HashSet {
fn add_cloze_numbers_in_text_with_clozes(nodes: &[TextOrCloze], set: &mut HashSet) {
for node in nodes {
if let TextOrCloze::Cloze(cloze) = node {
- if cloze.ordinal != 0 {
- set.insert(cloze.ordinal);
- add_cloze_numbers_in_text_with_clozes(&cloze.nodes, set);
+ for &ordinal in &cloze.ordinals {
+ if ordinal != 0 {
+ set.insert(ordinal);
+ }
}
+ add_cloze_numbers_in_text_with_clozes(&cloze.nodes, set);
}
}
}
@@ -654,4 +683,160 @@ mod test {
)
);
}
+
+ #[test]
+ fn multi_card_card_generation() {
+ let text = "{{c1,2,3::multi}}";
+ assert_eq!(
+ cloze_number_in_fields(vec![text]),
+ vec![1, 2, 3].into_iter().collect::>()
+ );
+ }
+
+ #[test]
+ fn multi_card_cloze_basic() {
+ let text = "{{c1,2::shared}} word and {{c1::first}} vs {{c2::second}}";
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+ "[...] word and [...] vs second"
+ );
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+ "[...] word and first vs [...]"
+ );
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, false)).as_ref(),
+ "shared word and first vs second"
+ );
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 2, false)).as_ref(),
+ "shared word and first vs second"
+ );
+ assert_eq!(
+ cloze_numbers_in_string(text),
+ vec![1, 2].into_iter().collect::>()
+ );
+ }
+
+ #[test]
+ fn multi_card_cloze_html_attributes() {
+ let text = "{{c1,2,3::multi}}";
+
+ let card1_html = reveal_cloze_text(text, 1, true);
+ assert!(card1_html.contains(r#"data-ordinal="1,2,3""#));
+
+ let card2_html = reveal_cloze_text(text, 2, true);
+ assert!(card2_html.contains(r#"data-ordinal="1,2,3""#));
+
+ let card3_html = reveal_cloze_text(text, 3, true);
+ assert!(card3_html.contains(r#"data-ordinal="1,2,3""#));
+ }
+
+ #[test]
+ fn multi_card_cloze_with_hints() {
+ let text = "{{c1,2::answer::hint}}";
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+ "[hint]"
+ );
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+ "[hint]"
+ );
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, false)).as_ref(),
+ "answer"
+ );
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 2, false)).as_ref(),
+ "answer"
+ );
+ }
+
+ #[test]
+ fn multi_card_cloze_edge_cases() {
+ assert_eq!(
+ cloze_numbers_in_string("{{c1,1,2::test}}"),
+ vec![1, 2].into_iter().collect::>()
+ );
+
+ assert_eq!(
+ cloze_numbers_in_string("{{c0,1,2::test}}"),
+ vec![1, 2].into_iter().collect::>()
+ );
+
+ assert_eq!(
+ cloze_numbers_in_string("{{c1,,3::test}}"),
+ vec![1, 3].into_iter().collect::>()
+ );
+ }
+
+ #[test]
+ fn multi_card_cloze_only_filter() {
+ let text = "{{c1,2::shared}} and {{c1::first}} vs {{c2::second}}";
+
+ assert_eq!(reveal_cloze_text_only(text, 1, true), "..., ...");
+ assert_eq!(reveal_cloze_text_only(text, 2, true), "..., ...");
+ assert_eq!(reveal_cloze_text_only(text, 1, false), "shared, first");
+ assert_eq!(reveal_cloze_text_only(text, 2, false), "shared, second");
+ }
+
+ #[test]
+ fn multi_card_nested_cloze() {
+ let text = "{{c1,2::outer {{c3::inner}}}}";
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+ "[...]"
+ );
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 2, true)).as_ref(),
+ "[...]"
+ );
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 3, true)).as_ref(),
+ "outer [...]"
+ );
+
+ assert_eq!(
+ cloze_numbers_in_string(text),
+ vec![1, 2, 3].into_iter().collect::>()
+ );
+ }
+
+ #[test]
+ fn nested_parent_child_card_same_cloze() {
+ let text = "{{c1::outer {{c1::inner}}}}";
+
+ assert_eq!(
+ strip_html(&reveal_cloze_text(text, 1, true)).as_ref(),
+ "[...]"
+ );
+
+ assert_eq!(
+ cloze_numbers_in_string(text),
+ vec![1].into_iter().collect::>()
+ );
+ }
+
+ #[test]
+ fn multi_card_image_occlusion() {
+ let text = "{{c1,2::image-occlusion:rect:left=10:top=20:width=30:height=40}}";
+
+ let occlusions = parse_image_occlusions(text);
+ assert_eq!(occlusions.len(), 2);
+ assert!(occlusions.iter().any(|o| o.ordinal == 1));
+ assert!(occlusions.iter().any(|o| o.ordinal == 2));
+
+ let card1_html = reveal_cloze_text(text, 1, true);
+ assert!(card1_html.contains(r#"data-ordinal="1,2""#));
+
+ let card2_html = reveal_cloze_text(text, 2, true);
+ assert!(card2_html.contains(r#"data-ordinal="1,2""#));
+ }
}
diff --git a/rslib/src/collection/service.rs b/rslib/src/collection/service.rs
index 2050a6897c2..a37360782ec 100644
--- a/rslib/src/collection/service.rs
+++ b/rslib/src/collection/service.rs
@@ -1,8 +1,10 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
+use anki_proto::collection::GetCustomColoursResponse;
use anki_proto::generic;
use crate::collection::Collection;
+use crate::config::ConfigKey;
use crate::error;
use crate::prelude::BoolKey;
use crate::prelude::Op;
@@ -62,4 +64,13 @@ impl crate::services::CollectionService for Collection {
})
.map(Into::into)
}
+
+ fn get_custom_colours(
+ &mut self,
+ ) -> error::Result {
+ let colours = self
+ .get_config_optional(ConfigKey::CustomColorPickerPalette)
+ .unwrap_or_default();
+ Ok(GetCustomColoursResponse { colours })
+ }
}
diff --git a/rslib/src/config/bool.rs b/rslib/src/config/bool.rs
index c76787cb081..1be9b255698 100644
--- a/rslib/src/config/bool.rs
+++ b/rslib/src/config/bool.rs
@@ -1,8 +1,6 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
-use serde::Deserialize;
-use serde_aux::field_attributes::deserialize_bool_from_anything;
use strum::IntoStaticStr;
use crate::prelude::*;
@@ -56,15 +54,6 @@ pub enum BoolKey {
AddingDefaultsToCurrentDeck,
}
-/// This is a workaround for old clients that used ints to represent boolean
-/// values. For new config items, prefer using a bool directly.
-#[derive(Deserialize, Default)]
-struct BoolLike(
- #[serde(deserialize_with = "deserialize_bool_from_anything")]
- #[allow(dead_code)]
- bool,
-);
-
impl Collection {
pub fn get_config_bool(&self, key: BoolKey) -> bool {
match key {
diff --git a/rslib/src/config/mod.rs b/rslib/src/config/mod.rs
index 5ece5b7e1e6..1e507281ac8 100644
--- a/rslib/src/config/mod.rs
+++ b/rslib/src/config/mod.rs
@@ -71,6 +71,7 @@ pub(crate) enum ConfigKey {
NextNewCardPosition,
#[strum(to_string = "schedVer")]
SchedulerVersion,
+ CustomColorPickerPalette,
}
#[derive(PartialEq, Eq, Serialize_repr, Deserialize_repr, Clone, Copy, Debug)]
diff --git a/rslib/src/deckconfig/schema11.rs b/rslib/src/deckconfig/schema11.rs
index 2d862a3a0c0..b7ed0acaa80 100644
--- a/rslib/src/deckconfig/schema11.rs
+++ b/rslib/src/deckconfig/schema11.rs
@@ -184,17 +184,13 @@ where
#[derive(Serialize_repr, Deserialize_repr, Debug, PartialEq, Eq, Clone)]
#[repr(u8)]
+#[derive(Default)]
pub enum NewCardOrderSchema11 {
Random = 0,
+ #[default]
Due = 1,
}
-impl Default for NewCardOrderSchema11 {
- fn default() -> Self {
- Self::Due
- }
-}
-
fn hard_factor_default() -> f32 {
1.2
}
diff --git a/rslib/src/import_export/package/apkg/import/media.rs b/rslib/src/import_export/package/apkg/import/media.rs
index 32bf7c807ae..20543e07498 100644
--- a/rslib/src/import_export/package/apkg/import/media.rs
+++ b/rslib/src/import_export/package/apkg/import/media.rs
@@ -17,6 +17,7 @@ use crate::import_export::package::media::SafeMediaEntry;
use crate::import_export::ImportProgress;
use crate::media::files::add_hash_suffix_to_file_stem;
use crate::media::files::sha1_of_reader;
+use crate::media::Checksums;
use crate::prelude::*;
use crate::progress::ThrottlingProgressHandler;
@@ -75,7 +76,7 @@ impl Context<'_> {
fn prepare_media(
media_entries: Vec,
archive: &mut ZipArchive,
- existing_sha1s: &HashMap,
+ existing_sha1s: &Checksums,
progress: &mut ThrottlingProgressHandler,
) -> Result {
let mut media_map = MediaUseMap::default();
diff --git a/rslib/src/import_export/text/csv/import.rs b/rslib/src/import_export/text/csv/import.rs
index e45bbca1b84..31dee84e498 100644
--- a/rslib/src/import_export/text/csv/import.rs
+++ b/rslib/src/import_export/text/csv/import.rs
@@ -1,6 +1,7 @@
// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
+use std::collections::HashSet;
use std::io::BufRead;
use std::io::BufReader;
use std::io::Read;
@@ -106,6 +107,8 @@ struct ColumnContext {
notetype_column: Option,
/// Source column indices for the fields of a notetype
field_source_columns: FieldSourceColumns,
+ /// Metadata column indices (1-based)
+ meta_columns: HashSet,
/// How fields are converted to strings. Used for escaping HTML if
/// appropriate.
stringify: fn(&str) -> String,
@@ -119,6 +122,7 @@ impl ColumnContext {
deck_column: metadata.deck()?.column(),
notetype_column: metadata.notetype()?.column(),
field_source_columns: metadata.field_source_columns()?,
+ meta_columns: metadata.meta_columns(),
stringify: stringify_fn(metadata.is_html),
})
}
@@ -166,11 +170,19 @@ impl ColumnContext {
}
fn gather_note_fields(&self, record: &csv::StringRecord) -> Vec> {
- let stringify = self.stringify;
- self.field_source_columns
- .iter()
- .map(|opt| opt.and_then(|idx| record.get(idx - 1)).map(stringify))
- .collect()
+ let op = |i| record.get(i - 1).map(self.stringify);
+ if !self.field_source_columns.is_empty() {
+ self.field_source_columns
+ .iter()
+ .map(|opt| opt.and_then(op))
+ .collect()
+ } else {
+ // notetype column provided, assume all non-metadata columns are notetype fields
+ (1..=record.len())
+ .filter(|i| !self.meta_columns.contains(i))
+ .map(op)
+ .collect()
+ }
}
}
diff --git a/rslib/src/import_export/text/csv/metadata.rs b/rslib/src/import_export/text/csv/metadata.rs
index d505c60d2f9..cd41508136a 100644
--- a/rslib/src/import_export/text/csv/metadata.rs
+++ b/rslib/src/import_export/text/csv/metadata.rs
@@ -291,11 +291,8 @@ impl CsvMetadataHelpers for CsvMetadata {
.map(|&i| (i > 0).then_some(i as usize))
.collect(),
CsvNotetype::NotetypeColumn(_) => {
- let meta_columns = self.meta_columns();
- (1..self.column_labels.len() + 1)
- .filter(|idx| !meta_columns.contains(idx))
- .map(Some)
- .collect()
+ // each row's notetype could have varying number of fields
+ vec![]
}
})
}
diff --git a/rslib/src/media/check.rs b/rslib/src/media/check.rs
index 20d684826b4..9545441c174 100644
--- a/rslib/src/media/check.rs
+++ b/rslib/src/media/check.rs
@@ -552,6 +552,8 @@ pub(crate) mod test {
use super::*;
use crate::collection::CollectionBuilder;
+ use crate::sync::media::MAX_MEDIA_FILENAME_LENGTH;
+ use crate::tests::NoteAdder;
fn common_setup() -> Result<(TempDir, MediaManager, Collection)> {
let dir = tempdir()?;
@@ -869,4 +871,30 @@ Unused: unused.jpg
Ok(())
}
+
+ #[test]
+ fn long_filename_rename_not_reported_as_unused() -> Result<()> {
+ let (_dir, mgr, mut col) = common_setup()?;
+
+ let long_filename = format!("{}.mp3", "a".repeat(MAX_MEDIA_FILENAME_LENGTH + 1));
+
+ NoteAdder::basic(&mut col)
+ .fields(&["test", &format!("[sound:{}]", long_filename)])
+ .add(&mut col);
+
+ write_file(mgr.media_folder.join(&long_filename), "audio data")?;
+
+ let output = {
+ let mut checker = col.media_checker()?;
+ checker.check()?
+ };
+
+ assert!(output.renamed.contains_key(&long_filename));
+ let new_filename = output.renamed.get(&long_filename).unwrap();
+ assert!(new_filename.len() <= MAX_MEDIA_FILENAME_LENGTH);
+ assert!(!output.unused.contains(new_filename));
+ assert!(!output.missing.contains(new_filename));
+
+ Ok(())
+ }
}
diff --git a/rslib/src/media/files.rs b/rslib/src/media/files.rs
index ce17b40bb94..b098eb19e71 100644
--- a/rslib/src/media/files.rs
+++ b/rslib/src/media/files.rs
@@ -173,7 +173,9 @@ pub fn add_data_to_folder_uniquely<'a, P>(
where
P: AsRef,
{
- let normalized_name = normalize_filename(desired_name);
+ // force lowercase to account for case-insensitive filesystems
+ // but not within normalize_filename, for existing media refs
+ let normalized_name: Cow<_> = normalize_filename(desired_name).to_lowercase().into();
let mut target_path = folder.as_ref().join(normalized_name.as_ref());
@@ -496,8 +498,14 @@ mod test {
"test.mp3"
);
- // different contents
+ // different contents, filenames differ only by case
let h2 = sha1_of_data(b"hello1");
+ assert_eq!(
+ add_data_to_folder_uniquely(dpath, "Test.mp3", b"hello1", h2).unwrap(),
+ "test-88fdd585121a4ccb3d1540527aee53a77c77abb8.mp3"
+ );
+
+ // same contents, filenames differ only by case
assert_eq!(
add_data_to_folder_uniquely(dpath, "test.mp3", b"hello1", h2).unwrap(),
"test-88fdd585121a4ccb3d1540527aee53a77c77abb8.mp3"
diff --git a/rslib/src/media/mod.rs b/rslib/src/media/mod.rs
index 259dd52f8b4..8a599fbecc4 100644
--- a/rslib/src/media/mod.rs
+++ b/rslib/src/media/mod.rs
@@ -6,7 +6,6 @@ pub mod files;
mod service;
use std::borrow::Cow;
-use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
@@ -22,6 +21,7 @@ use crate::progress::ThrottlingProgressHandler;
use crate::sync::http_client::HttpSyncClient;
use crate::sync::login::SyncAuth;
use crate::sync::media::database::client::changetracker::ChangeTracker;
+pub use crate::sync::media::database::client::Checksums;
use crate::sync::media::database::client::MediaDatabase;
use crate::sync::media::database::client::MediaEntry;
use crate::sync::media::progress::MediaSyncProgress;
@@ -157,7 +157,7 @@ impl MediaManager {
pub fn all_checksums_after_checking(
&self,
progress: impl FnMut(usize) -> bool,
- ) -> Result> {
+ ) -> Result {
ChangeTracker::new(&self.media_folder, progress).register_changes(&self.db)?;
self.db.all_registered_checksums()
}
@@ -176,7 +176,7 @@ impl MediaManager {
/// All checksums without registering changes first.
#[cfg(test)]
- pub(crate) fn all_checksums_as_is(&self) -> HashMap {
+ pub(crate) fn all_checksums_as_is(&self) -> Checksums {
self.db.all_registered_checksums().unwrap()
}
}
diff --git a/rslib/src/notetype/stock.rs b/rslib/src/notetype/stock.rs
index 9b5df66d56b..b27881809fa 100644
--- a/rslib/src/notetype/stock.rs
+++ b/rslib/src/notetype/stock.rs
@@ -122,7 +122,7 @@ pub(crate) fn basic(tr: &I18n) -> Notetype {
pub(crate) fn basic_typing(tr: &I18n) -> Notetype {
let mut nt = basic(tr);
- nt.config.original_stock_kind = StockKind::BasicTyping as i32;
+ nt.config.original_stock_kind = OriginalStockKind::BasicTyping as i32;
nt.name = tr.notetypes_basic_type_answer_name().into();
let front = tr.notetypes_front_field();
let back = tr.notetypes_back_field();
@@ -138,7 +138,7 @@ pub(crate) fn basic_typing(tr: &I18n) -> Notetype {
pub(crate) fn basic_forward_reverse(tr: &I18n) -> Notetype {
let mut nt = basic(tr);
- nt.config.original_stock_kind = StockKind::BasicAndReversed as i32;
+ nt.config.original_stock_kind = OriginalStockKind::BasicAndReversed as i32;
nt.name = tr.notetypes_basic_reversed_name().into();
let front = tr.notetypes_front_field();
let back = tr.notetypes_back_field();
@@ -156,7 +156,7 @@ pub(crate) fn basic_forward_reverse(tr: &I18n) -> Notetype {
pub(crate) fn basic_optional_reverse(tr: &I18n) -> Notetype {
let mut nt = basic_forward_reverse(tr);
- nt.config.original_stock_kind = StockKind::BasicOptionalReversed as i32;
+ nt.config.original_stock_kind = OriginalStockKind::BasicOptionalReversed as i32;
nt.name = tr.notetypes_basic_optional_reversed_name().into();
let addrev = tr.notetypes_add_reverse_field();
nt.add_field(addrev.as_ref());
diff --git a/rslib/src/revlog/mod.rs b/rslib/src/revlog/mod.rs
index f5269838809..3e22890b10c 100644
--- a/rslib/src/revlog/mod.rs
+++ b/rslib/src/revlog/mod.rs
@@ -85,6 +85,15 @@ impl RevlogEntry {
.unwrap()
}
+ pub(crate) fn last_interval_secs(&self) -> u32 {
+ u32::try_from(if self.last_interval > 0 {
+ self.last_interval.saturating_mul(86_400)
+ } else {
+ self.last_interval.saturating_mul(-1)
+ })
+ .unwrap()
+ }
+
/// Returns true if this entry represents a reset operation.
/// These entries are created when a card is reset using
/// [`Collection::reschedule_cards_as_new`].
@@ -152,7 +161,7 @@ impl Collection {
) -> Result<()> {
let ease_factor = u32::from(
card.memory_state
- .map(|s| ((s.difficulty_shifted() * 1000.) as u16))
+ .map(|s| (s.difficulty_shifted() * 1000.) as u16)
.unwrap_or(card.ease_factor),
);
let entry = RevlogEntry {
diff --git a/rslib/src/scheduler/answering/mod.rs b/rslib/src/scheduler/answering/mod.rs
index 6ff8c6e2d70..a71c6330fd7 100644
--- a/rslib/src/scheduler/answering/mod.rs
+++ b/rslib/src/scheduler/answering/mod.rs
@@ -443,9 +443,20 @@ impl Collection {
.storage
.get_deck(card.deck_id)?
.or_not_found(card.deck_id)?;
- let config = self.home_deck_config(deck.config_id(), card.original_deck_id)?;
+ let home_deck = if card.original_deck_id.0 == 0 {
+ &deck
+ } else {
+ &self
+ .storage
+ .get_deck(card.original_deck_id)?
+ .or_not_found(card.original_deck_id)?
+ };
+ let config = self
+ .storage
+ .get_deck_config(home_deck.config_id().or_invalid("home deck is filtered")?)?
+ .unwrap_or_default();
- let desired_retention = deck.effective_desired_retention(&config);
+ let desired_retention = home_deck.effective_desired_retention(&config);
let fsrs_enabled = self.get_config_bool(BoolKey::Fsrs);
let fsrs_next_states = if fsrs_enabled {
let params = config.fsrs_params();
diff --git a/rslib/src/scheduler/fsrs/error.rs b/rslib/src/scheduler/fsrs/error.rs
index d5b596a3615..404ee36054a 100644
--- a/rslib/src/scheduler/fsrs/error.rs
+++ b/rslib/src/scheduler/fsrs/error.rs
@@ -13,13 +13,7 @@ impl From for AnkiError {
FSRSError::OptimalNotFound => AnkiError::FsrsUnableToDetermineDesiredRetention,
FSRSError::Interrupted => AnkiError::Interrupted,
FSRSError::InvalidParameters => AnkiError::FsrsParamsInvalid,
- FSRSError::InvalidInput => AnkiError::InvalidInput {
- source: InvalidInputError {
- message: "invalid params provided".to_string(),
- source: None,
- backtrace: None,
- },
- },
+ FSRSError::InvalidInput => AnkiError::FsrsParamsInvalid,
FSRSError::InvalidDeckSize => AnkiError::InvalidInput {
source: InvalidInputError {
message: "no cards to simulate".to_string(),
diff --git a/rslib/src/scheduler/fsrs/memory_state.rs b/rslib/src/scheduler/fsrs/memory_state.rs
index 420ead5a334..303bbfd91a9 100644
--- a/rslib/src/scheduler/fsrs/memory_state.rs
+++ b/rslib/src/scheduler/fsrs/memory_state.rs
@@ -136,6 +136,19 @@ impl Collection {
let deckconfig_id = deck.config_id().unwrap();
// reschedule it
let original_interval = card.interval;
+ let min_interval = |interval: u32| {
+ let previous_interval =
+ last_info.previous_interval.unwrap_or(0);
+ if interval > previous_interval {
+ // interval grew; don't allow fuzzed interval to
+ // be less than previous+1
+ previous_interval + 1
+ } else {
+ // interval shrunk; don't restrict negative fuzz
+ 0
+ }
+ .max(1)
+ };
let interval = fsrs.next_interval(
Some(state.stability),
desired_retention,
@@ -146,7 +159,7 @@ impl Collection {
.and_then(|r| {
r.find_interval(
interval,
- 1,
+ min_interval(interval as u32),
req.max_interval,
days_elapsed as u32,
deckconfig_id,
@@ -157,7 +170,7 @@ impl Collection {
with_review_fuzz(
card.get_fuzz_factor(true),
interval,
- 1,
+ min_interval(interval as u32),
req.max_interval,
)
});
@@ -310,6 +323,9 @@ pub(crate) struct LastRevlogInfo {
/// reviewed the card and now, so that we can determine an accurate period
/// when the card has subsequently been rescheduled to a different day.
pub(crate) last_reviewed_at: Option,
+ /// The interval before the latest review. Used to prevent fuzz from going
+ /// backwards when rescheduling the card
+ pub(crate) previous_interval: Option,
}
/// Return a map of cards to info about last review.
@@ -321,14 +337,27 @@ pub(crate) fn get_last_revlog_info(revlogs: &[RevlogEntry]) -> HashMap= 0 && e.button_chosen > 1 {
+ Some(e.last_interval as u32)
+ } else {
+ None
+ };
} else if e.is_reset() {
last_reviewed_at = None;
+ previous_interval = None;
}
}
- out.insert(card_id, LastRevlogInfo { last_reviewed_at });
+ out.insert(
+ card_id,
+ LastRevlogInfo {
+ last_reviewed_at,
+ previous_interval,
+ },
+ );
});
out
}
diff --git a/rslib/src/scheduler/fsrs/params.rs b/rslib/src/scheduler/fsrs/params.rs
index 726870fe13f..6f438a5d2bc 100644
--- a/rslib/src/scheduler/fsrs/params.rs
+++ b/rslib/src/scheduler/fsrs/params.rs
@@ -174,7 +174,7 @@ impl Collection {
}
}
- let health_check_passed = if health_check {
+ let health_check_passed = if health_check && input.train_set.len() > 300 {
let fsrs = FSRS::new(None)?;
fsrs.evaluate_with_time_series_splits(input, |_| true)
.ok()
@@ -478,27 +478,42 @@ pub(crate) fn reviews_for_fsrs(
}))
.collect_vec();
- let skip = if training { 1 } else { 0 };
- // Convert the remaining entries into separate FSRSItems, where each item
- // contains all reviews done until then.
- let items: Vec<(RevlogId, FSRSItem)> = entries
- .iter()
- .enumerate()
- .skip(skip)
- .map(|(outer_idx, entry)| {
- let reviews = entries
- .iter()
- .take(outer_idx + 1)
- .enumerate()
- .map(|(inner_idx, r)| FSRSReview {
- rating: r.button_chosen as u32,
- delta_t: delta_ts[inner_idx],
- })
- .collect();
- (entry.id, FSRSItem { reviews })
- })
- .filter(|(_, item)| !training || item.reviews.last().unwrap().delta_t > 0)
- .collect_vec();
+ let items = if training {
+ // Convert the remaining entries into separate FSRSItems, where each item
+ // contains all reviews done until then.
+ let mut items = Vec::with_capacity(entries.len());
+ let mut current_reviews = Vec::with_capacity(entries.len());
+ for (idx, (entry, &delta_t)) in entries.iter().zip(delta_ts.iter()).enumerate() {
+ current_reviews.push(FSRSReview {
+ rating: entry.button_chosen as u32,
+ delta_t,
+ });
+ if idx >= 1 && delta_t > 0 {
+ items.push((
+ entry.id,
+ FSRSItem {
+ reviews: current_reviews.clone(),
+ },
+ ));
+ }
+ }
+ items
+ } else {
+ // When not training, we only need the final FSRS item, which represents
+ // the complete history of the card. This avoids expensive clones in a loop.
+ let reviews = entries
+ .iter()
+ .zip(delta_ts.iter())
+ .map(|(entry, &delta_t)| FSRSReview {
+ rating: entry.button_chosen as u32,
+ delta_t,
+ })
+ .collect();
+ let last_entry = entries.last().unwrap();
+
+ vec![(last_entry.id, FSRSItem { reviews })]
+ };
+
if items.is_empty() {
None
} else {
@@ -591,8 +606,6 @@ pub(crate) mod tests {
};
}
- pub(crate) use fsrs_items;
-
#[test]
fn delta_t_is_correct() -> Result<()> {
assert_eq!(
@@ -738,7 +751,7 @@ pub(crate) mod tests {
],
false,
),
- fsrs_items!([review(0)], [review(0), review(1)])
+ fsrs_items!([review(0), review(1)])
);
}
@@ -809,7 +822,7 @@ pub(crate) mod tests {
// R | A X R
assert_eq!(
convert_ignore_before(revlogs, false, days_ago_ms(9)),
- fsrs_items!([review(0)], [review(0), review(2)])
+ fsrs_items!([review(0), review(2)])
);
}
@@ -828,6 +841,9 @@ pub(crate) mod tests {
assert_eq!(
convert_ignore_before(revlogs, false, days_ago_ms(9))
.unwrap()
+ .last()
+ .unwrap()
+ .reviews
.len(),
2
);
@@ -849,6 +865,9 @@ pub(crate) mod tests {
assert_eq!(
convert_ignore_before(revlogs, false, days_ago_ms(9))
.unwrap()
+ .last()
+ .unwrap()
+ .reviews
.len(),
2
);
diff --git a/rslib/src/scheduler/fsrs/rescheduler.rs b/rslib/src/scheduler/fsrs/rescheduler.rs
index db490b3e4c9..37c824230eb 100644
--- a/rslib/src/scheduler/fsrs/rescheduler.rs
+++ b/rslib/src/scheduler/fsrs/rescheduler.rs
@@ -115,13 +115,14 @@ impl Rescheduler {
pub fn find_interval(
&self,
interval: f32,
- minimum: u32,
- maximum: u32,
+ minimum_interval: u32,
+ maximum_interval: u32,
days_elapsed: u32,
deckconfig_id: DeckConfigId,
fuzz_seed: Option,
) -> Option {
- let (before_days, after_days) = constrained_fuzz_bounds(interval, minimum, maximum);
+ let (before_days, after_days) =
+ constrained_fuzz_bounds(interval, minimum_interval, maximum_interval);
// Don't reschedule the card when it's overdue
if after_days < days_elapsed {
diff --git a/rslib/src/search/parser.rs b/rslib/src/search/parser.rs
index cbdba3d9f67..5928bf486bc 100644
--- a/rslib/src/search/parser.rs
+++ b/rslib/src/search/parser.rs
@@ -392,6 +392,11 @@ fn parse_tag(s: &str) -> ParseResult<'_, SearchNode> {
tag: unescape_quotes(re),
mode: FieldSearchMode::Regex,
}
+ } else if let Some(nc) = s.strip_prefix("nc:") {
+ SearchNode::Tag {
+ tag: unescape(nc)?,
+ mode: FieldSearchMode::NoCombining,
+ }
} else {
SearchNode::Tag {
tag: unescape(s)?,
diff --git a/rslib/src/search/sqlwriter.rs b/rslib/src/search/sqlwriter.rs
index 95249276c7e..2479b87aeef 100644
--- a/rslib/src/search/sqlwriter.rs
+++ b/rslib/src/search/sqlwriter.rs
@@ -311,8 +311,19 @@ impl SqlWriter<'_> {
}
s if s.contains(' ') => write!(self.sql, "false").unwrap(),
text => {
- write!(self.sql, "n.tags regexp ?").unwrap();
- let re = &to_custom_re(text, r"\S");
+ let text = if mode == FieldSearchMode::Normal {
+ write!(self.sql, "n.tags regexp ?").unwrap();
+ Cow::from(text)
+ } else {
+ write!(
+ self.sql,
+ "coalesce(process_text(n.tags, {}), n.tags) regexp ?",
+ ProcessTextFlags::NoCombining.bits()
+ )
+ .unwrap();
+ without_combining(text)
+ };
+ let re = &to_custom_re(&text, r"\S");
self.args.push(format!("(?i).* {re}(::| ).*"));
}
}
@@ -423,9 +434,10 @@ impl SqlWriter<'_> {
let timing = self.col.timing_today()?;
(timing.days_elapsed, timing.next_day_at, timing.now)
};
+ const NEW_TYPE: i8 = CardType::New as i8;
write!(
self.sql,
- "extract_fsrs_retrievability(c.data, case when c.odue !=0 then c.odue else c.due end, c.ivl, {elap}, {next_day_at}, {now}) {op} {r}"
+ "case when c.type = {NEW_TYPE} then false else (extract_fsrs_retrievability(c.data, case when c.odue !=0 then c.odue else c.due end, c.ivl, {elap}, {next_day_at}, {now}) {op} {r}) end"
)
.unwrap()
}
diff --git a/rslib/src/stats/card.rs b/rslib/src/stats/card.rs
index 008977fe967..0dabff5e52f 100644
--- a/rslib/src/stats/card.rs
+++ b/rslib/src/stats/card.rs
@@ -76,8 +76,15 @@ impl Collection {
note_id: card.note_id.into(),
deck: deck.human_name(),
added: card.id.as_secs().0,
- first_review: revlog.first().map(|entry| entry.id.as_secs().0),
- latest_review: revlog.last().map(|entry| entry.id.as_secs().0),
+ first_review: revlog
+ .iter()
+ .find(|entry| entry.has_rating())
+ .map(|entry| entry.id.as_secs().0),
+ // last_review_time is not used to ensure cram revlogs are included.
+ latest_review: revlog
+ .iter()
+ .rfind(|entry| entry.has_rating())
+ .map(|entry| entry.id.as_secs().0),
due_date: self.due_date(&card)?,
due_position: self.position(&card),
interval: card.interval,
@@ -220,6 +227,7 @@ fn stats_revlog_entry(
ease: entry.ease_factor,
taken_secs: entry.taken_millis as f32 / 1000.,
memory_state: None,
+ last_interval: entry.last_interval_secs(),
}
}
diff --git a/rslib/src/storage/card/filtered.rs b/rslib/src/storage/card/filtered.rs
index ef436f6e876..03f845f4e44 100644
--- a/rslib/src/storage/card/filtered.rs
+++ b/rslib/src/storage/card/filtered.rs
@@ -54,7 +54,7 @@ fn build_retrievability_query(
) -> String {
if fsrs {
format!(
- "extract_fsrs_relative_retrievability(c.data, case when c.odue !=0 then c.odue else c.due end, {today}, ivl, {next_day_at}, {now}) {order}"
+ "extract_fsrs_relative_retrievability(c.data, case when c.odue !=0 then c.odue else c.due end, ivl, {today}, {next_day_at}, {now}) {order}"
)
} else {
format!(
diff --git a/rslib/src/storage/card/mod.rs b/rslib/src/storage/card/mod.rs
index 3a5066ff407..9e06edf07f2 100644
--- a/rslib/src/storage/card/mod.rs
+++ b/rslib/src/storage/card/mod.rs
@@ -837,7 +837,7 @@ impl fmt::Display for ReviewOrderSubclause {
let next_day_at = timing.next_day_at.0;
let now = timing.now.0;
temp_string =
- format!("extract_fsrs_relative_retrievability(data, case when odue !=0 then odue else due end, {today}, ivl, {next_day_at}, {now}) {order}");
+ format!("extract_fsrs_relative_retrievability(data, case when odue !=0 then odue else due end, ivl, {today}, {next_day_at}, {now}) {order}");
&temp_string
}
ReviewOrderSubclause::Added => "nid asc, ord asc",
diff --git a/rslib/src/storage/sqlite.rs b/rslib/src/storage/sqlite.rs
index 3ce1baff016..95853afc90f 100644
--- a/rslib/src/storage/sqlite.rs
+++ b/rslib/src/storage/sqlite.rs
@@ -332,23 +332,30 @@ fn add_extract_fsrs_retrievability(db: &Connection) -> rusqlite::Result<()> {
return Ok(None);
};
let seconds_elapsed = if let Some(last_review_time) = card_data.last_review_time {
- now.saturating_sub(last_review_time.0) as u32
+ // This and any following
+ // (x as u32).saturating_sub(y as u32)
+ // must not be changed to
+ // x.saturating_sub(y) as u32
+ // as x and y are i64's and saturating_sub will therfore allow negative numbers
+ // before converting to u32 in the latter example.
+ (now as u32).saturating_sub(last_review_time.0 as u32)
} else if due > 365_000 {
// (re)learning card in seconds
let Ok(ivl) = ctx.get_raw(2).as_i64() else {
return Ok(None);
};
- let last_review_time = due.saturating_sub(ivl);
- now.saturating_sub(last_review_time) as u32
+ let last_review_time = (due as u32).saturating_sub(ivl as u32);
+ (now as u32).saturating_sub(last_review_time)
} else {
let Ok(ivl) = ctx.get_raw(2).as_i64() else {
return Ok(None);
};
- let Ok(days_elapsed) = ctx.get_raw(3).as_i64() else {
+ // timing.days_elapsed
+ let Ok(today) = ctx.get_raw(3).as_i64() else {
return Ok(None);
};
- let review_day = due.saturating_sub(ivl);
- days_elapsed.saturating_sub(review_day) as u32 * 86_400
+ let review_day = (due as u32).saturating_sub(ivl as u32);
+ (today as u32).saturating_sub(review_day) * 86_400
};
let decay = card_data.decay.unwrap_or(FSRS5_DEFAULT_DECAY);
let retrievability = card_data.memory_state().map(|state| {
@@ -364,7 +371,7 @@ fn add_extract_fsrs_retrievability(db: &Connection) -> rusqlite::Result<()> {
}
/// eg. extract_fsrs_relative_retrievability(card.data, card.due,
-/// timing.days_elapsed, card.ivl, timing.next_day_at, timing.now) -> float |
+/// card.ivl, timing.days_elapsed, timing.next_day_at, timing.now) -> float |
/// null. The higher the number, the higher the card's retrievability relative
/// to the configured desired retention.
fn add_extract_fsrs_relative_retrievability(db: &Connection) -> rusqlite::Result<()> {
@@ -378,25 +385,32 @@ fn add_extract_fsrs_relative_retrievability(db: &Connection) -> rusqlite::Result
let Ok(due) = ctx.get_raw(1).as_i64() else {
return Ok(None);
};
- let Ok(interval) = ctx.get_raw(3).as_i64() else {
+ let Ok(interval) = ctx.get_raw(2).as_i64() else {
return Ok(None);
};
+ /*
+ // Unused
let Ok(next_day_at) = ctx.get_raw(4).as_i64() else {
return Ok(None);
};
+ */
let Ok(now) = ctx.get_raw(5).as_i64() else {
return Ok(None);
};
- let days_elapsed = if due > 365_000 {
- // (re)learning
- (next_day_at as u32).saturating_sub(due as u32) / 86_400
+ let secs_elapsed = if due > 365_000 {
+ // (re)learning card with due in seconds
+
+ // Don't change this to now.subtracting_sub(due) as u32
+ // for the same reasons listed in the comment
+ // in add_extract_fsrs_retrievability
+ (now as u32).saturating_sub(due as u32)
} else {
- let Ok(days_elapsed) = ctx.get_raw(2).as_i64() else {
+ // timing.days_elapsed
+ let Ok(today) = ctx.get_raw(3).as_i64() else {
return Ok(None);
};
let review_day = due.saturating_sub(interval);
-
- (days_elapsed as u32).saturating_sub(review_day as u32)
+ (today as u32).saturating_sub(review_day as u32) * 86_400
};
if let Ok(card_data) = ctx.get_raw(0).as_str() {
if !card_data.is_empty() {
@@ -410,23 +424,12 @@ fn add_extract_fsrs_relative_retrievability(db: &Connection) -> rusqlite::Result
let seconds_elapsed =
if let Some(last_review_time) = card_data.last_review_time {
- now.saturating_sub(last_review_time.0) as u32
- } else if due > 365_000 {
- // (re)learning card in seconds
- let Ok(ivl) = ctx.get_raw(2).as_i64() else {
- return Ok(None);
- };
- let last_review_time = due.saturating_sub(ivl);
- now.saturating_sub(last_review_time) as u32
+ // Don't change this to now.subtracting_sub(due) as u32
+ // for the same reasons listed in the comment
+ // in add_extract_fsrs_retrievability
+ (now as u32).saturating_sub(last_review_time.0 as u32)
} else {
- let Ok(ivl) = ctx.get_raw(2).as_i64() else {
- return Ok(None);
- };
- let Ok(days_elapsed) = ctx.get_raw(3).as_i64() else {
- return Ok(None);
- };
- let review_day = due.saturating_sub(ivl);
- days_elapsed.saturating_sub(review_day) as u32 * 86_400
+ secs_elapsed
};
let current_retrievability = FSRS::new(None)
@@ -441,7 +444,7 @@ fn add_extract_fsrs_relative_retrievability(db: &Connection) -> rusqlite::Result
}
}
}
-
+ let days_elapsed = secs_elapsed / 86_400;
// FSRS data missing; fall back to SM2 ordering
Ok(Some(
-((days_elapsed as f32) + 0.001) / (interval as f32).max(1.0),
diff --git a/rslib/src/sync/media/database/client/mod.rs b/rslib/src/sync/media/database/client/mod.rs
index f9c6e5ed12d..fe3e7c84014 100644
--- a/rslib/src/sync/media/database/client/mod.rs
+++ b/rslib/src/sync/media/database/client/mod.rs
@@ -18,6 +18,20 @@ use crate::prelude::*;
pub mod changetracker;
+pub struct Checksums(HashMap);
+
+impl Checksums {
+ // case-fold filenames when checking files to be imported
+ // to account for case-insensitive filesystems
+ pub fn get(&self, key: impl AsRef) -> Option<&Sha1Hash> {
+ self.0.get(key.as_ref().to_lowercase().as_str())
+ }
+
+ pub fn contains_key(&self, key: impl AsRef) -> bool {
+ self.get(key).is_some()
+ }
+}
+
#[derive(Debug, PartialEq, Eq)]
pub struct MediaEntry {
pub fname: String,
@@ -175,11 +189,12 @@ delete from media where fname=?",
}
/// Returns all filenames and checksums, where the checksum is not null.
- pub(crate) fn all_registered_checksums(&self) -> error::Result> {
+ pub(crate) fn all_registered_checksums(&self) -> error::Result {
self.db
.prepare("SELECT fname, csum FROM media WHERE csum IS NOT NULL")?
.query_and_then([], row_to_name_and_checksum)?
- .collect()
+ .collect::>()
+ .map(Checksums)
}
pub(crate) fn force_resync(&self) -> error::Result<()> {
diff --git a/rslib/src/typeanswer.rs b/rslib/src/typeanswer.rs
index 08c638e1275..9bf3dc47c0b 100644
--- a/rslib/src/typeanswer.rs
+++ b/rslib/src/typeanswer.rs
@@ -58,7 +58,7 @@ trait DiffTrait {
if self.get_typed() == self.get_expected() {
format_typeans!(format!(
"{}",
- self.get_expected_original()
+ htmlescape::encode_minimal(&self.get_expected_original())
))
} else {
let output = self.to_tokens();
@@ -391,6 +391,15 @@ mod test {
assert_eq!(ctx, "
123");
}
+ #[test]
+ fn correct_input_is_escaped() {
+ let ctx = Diff::new("source /bin/activate", "source /bin/activate");
+ assert_eq!(
+ ctx.to_html(),
+ "source <dir>/bin/activate"
+ );
+ }
+
#[test]
fn correct_input_is_collapsed() {
let ctx = Diff::new("123", "123");
diff --git a/rslib/src/undo/mod.rs b/rslib/src/undo/mod.rs
index c3f81e84eed..7c2707e57d6 100644
--- a/rslib/src/undo/mod.rs
+++ b/rslib/src/undo/mod.rs
@@ -29,19 +29,14 @@ impl UndoableOp {
}
}
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Default)]
enum UndoMode {
+ #[default]
NormalOp,
Undoing,
Redoing,
}
-impl Default for UndoMode {
- fn default() -> Self {
- Self::NormalOp
- }
-}
-
pub struct UndoStatus {
pub undo: Option,
pub redo: Option,
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 452c65213b4..b6be5554380 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,3 @@
[toolchain]
# older versions may fail to compile; newer versions may fail the clippy tests
-channel = "1.89.0"
+channel = "1.92.0"
diff --git a/tools/minilints/src/main.rs b/tools/minilints/src/main.rs
index c99fbe06e65..b72d392947a 100644
--- a/tools/minilints/src/main.rs
+++ b/tools/minilints/src/main.rs
@@ -202,7 +202,8 @@ fn sveltekit_temp_file(path: &str) -> bool {
}
fn check_cargo_deny() -> Result<()> {
- Command::run("cargo install cargo-deny@0.18.3")?;
+ // WARNING: make sure to update version in .buildekite/linux as well
+ Command::run("cargo install cargo-deny@0.19.0")?;
Command::run("cargo deny check")?;
Ok(())
}
@@ -255,9 +256,7 @@ fn check_for_unstaged_changes() {
}
fn generate_licences() -> Result {
- if which::which("cargo-license").is_err() {
- Command::run("cargo install cargo-license@0.5.1")?;
- }
+ Command::run("cargo install cargo-license@0.7.0")?;
let output = Command::run_with_output([
"cargo-license",
"--features",
diff --git a/tools/run.py b/tools/run.py
index da0baa2c439..e17e22a979d 100644
--- a/tools/run.py
+++ b/tools/run.py
@@ -5,8 +5,6 @@
import sys
sys.path.extend(["pylib", "qt", "out/pylib", "out/qt"])
-if sys.platform == "win32":
- os.environ["PATH"] += ";out\\extracted\\win_amd64_audio"
import aqt
diff --git a/ts/editable/ContentEditable.svelte b/ts/editable/ContentEditable.svelte
index d0cfe89df7a..116eb2ffde1 100644
--- a/ts/editable/ContentEditable.svelte
+++ b/ts/editable/ContentEditable.svelte
@@ -20,6 +20,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
preventBuiltinShortcuts,
useFocusHandler,
} from "./content-editable";
+ import { pageTheme } from "$lib/sveltelib/theme";
export let resolve: (editable: HTMLElement) => void;
@@ -41,6 +42,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
-
+ saveCustomColours({})}
+/>
{#if keyCombination}
inputRef.click()} />
diff --git a/ts/editor/editor-toolbar/HighlightColorButton.svelte b/ts/editor/editor-toolbar/HighlightColorButton.svelte
index 865ec5668c6..f89f7a99adf 100644
--- a/ts/editor/editor-toolbar/HighlightColorButton.svelte
+++ b/ts/editor/editor-toolbar/HighlightColorButton.svelte
@@ -19,6 +19,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
import ColorPicker from "./ColorPicker.svelte";
import { context as editorToolbarContext } from "./EditorToolbar.svelte";
import WithColorHelper from "./WithColorHelper.svelte";
+ import { saveCustomColours } from "@generated/backend";
export let color: string;
@@ -134,7 +135,10 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
color = setColor(event);
bridgeCommand(`lastHighlightColor:${color}`);
}}
- on:change={() => setTextColor()}
+ on:change={() => {
+ setTextColor();
+ saveCustomColours({});
+ }}
/>
diff --git a/ts/editor/editor-toolbar/TextColorButton.svelte b/ts/editor/editor-toolbar/TextColorButton.svelte
index 16595318046..ce80aae49bd 100644
--- a/ts/editor/editor-toolbar/TextColorButton.svelte
+++ b/ts/editor/editor-toolbar/TextColorButton.svelte
@@ -22,6 +22,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
import ColorPicker from "./ColorPicker.svelte";
import { context as editorToolbarContext } from "./EditorToolbar.svelte";
import WithColorHelper from "./WithColorHelper.svelte";
+ import { saveCustomColours } from "@generated/backend";
export let color: string;
@@ -158,6 +159,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
setTimeout(() => {
setTextColor();
}, 200);
+ saveCustomColours({});
}}
/>
diff --git a/ts/lib/components/HelpModal.svelte b/ts/lib/components/HelpModal.svelte
index cf629253728..7ee42595010 100644
--- a/ts/lib/components/HelpModal.svelte
+++ b/ts/lib/components/HelpModal.svelte
@@ -23,6 +23,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
export let title: string;
export let url: string;
+ export let linkLabel: string | undefined = undefined;
export let startIndex = 0;
export let helpSections: HelpItem[];
export let fsrs = false;
@@ -106,11 +107,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
diff --git a/ts/lib/tslib/help-page.ts b/ts/lib/tslib/help-page.ts
index e3f209c6ae0..e2b2e3da4ef 100644
--- a/ts/lib/tslib/help-page.ts
+++ b/ts/lib/tslib/help-page.ts
@@ -27,7 +27,8 @@ export const HelpPage = {
limitsFromTop: "https://docs.ankiweb.net/deck-options.html#limits-start-from-top",
dailyLimits: "https://docs.ankiweb.net/deck-options.html#daily-limits",
audio: "https://docs.ankiweb.net/deck-options.html#audio",
- fsrs: "http://docs.ankiweb.net/deck-options.html#fsrs",
+ fsrs: "https://docs.ankiweb.net/deck-options.html#fsrs",
+ desiredRetention: "https://docs.ankiweb.net/deck-options.html#desired-retention",
},
Leeches: {
leeches: "https://docs.ankiweb.net/leeches.html#leeches",
diff --git a/ts/lib/tslib/uuid.ts b/ts/lib/tslib/uuid.ts
deleted file mode 100644
index 8598261b0a8..00000000000
--- a/ts/lib/tslib/uuid.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright: Ankitects Pty Ltd and contributors
-// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
-
-/**
- * TODO replace with crypto.randomUUID
- */
-export function randomUUID(): string {
- const value = `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`;
-
- return value.replace(/[018]/g, (character: string): string =>
- (
- Number(character)
- ^ (crypto.getRandomValues(new Uint8Array(1))[0]
- & (15 >> (Number(character) / 4)))
- ).toString(16));
-}
diff --git a/ts/lib/tslib/wrap.ts b/ts/lib/tslib/wrap.ts
index 39b10e9d14a..e22c3e6d85f 100644
--- a/ts/lib/tslib/wrap.ts
+++ b/ts/lib/tslib/wrap.ts
@@ -4,7 +4,12 @@
import { getRange, getSelection } from "./cross-browser";
function wrappedExceptForWhitespace(text: string, front: string, back: string): string {
- const match = text.match(/^(\s*)([^]*?)(\s*)$/)!;
+ const normalizedText = text
+ .replace(/ /g, " ")
+ .replace(/ /g, " ")
+ .replace(/\u00A0/g, " ");
+
+ const match = normalizedText.match(/^(\s*)([^]*?)(\s*)$/)!;
return match[1] + front + match[2] + back + match[3];
}
diff --git a/ts/reviewer/images.ts b/ts/reviewer/images.ts
index 05de2415847..35a2e269fe3 100644
--- a/ts/reviewer/images.ts
+++ b/ts/reviewer/images.ts
@@ -28,6 +28,8 @@ function extractImageSrcs(fragment: DocumentFragment): string[] {
function createImage(src: string): HTMLImageElement {
const img = new Image();
img.src = src;
+ img.decoding = "async";
+ img.decode();
return img;
}
diff --git a/ts/routes/deck-options/DeckOptionsPage.svelte b/ts/routes/deck-options/DeckOptionsPage.svelte
index 599ee7f2c25..4b4343961c1 100644
--- a/ts/routes/deck-options/DeckOptionsPage.svelte
+++ b/ts/routes/deck-options/DeckOptionsPage.svelte
@@ -132,7 +132,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
@use "$lib/sass/breakpoints" as bp;
.deck-options-page {
- overflow-x: hidden;
+ overflow-x: auto;
:global(.container-columns) {
display: grid;
diff --git a/ts/routes/graphs/TrueRetention.svelte b/ts/routes/graphs/TrueRetention.svelte
index 4a97388310f..12d17079b5a 100644
--- a/ts/routes/graphs/TrueRetention.svelte
+++ b/ts/routes/graphs/TrueRetention.svelte
@@ -72,7 +72,8 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
>
{
modal = e.detail.modal;
diff --git a/ts/routes/image-occlusion/Toolbar.svelte b/ts/routes/image-occlusion/Toolbar.svelte
index 8775de936b4..b00e420876b 100644
--- a/ts/routes/image-occlusion/Toolbar.svelte
+++ b/ts/routes/image-occlusion/Toolbar.svelte
@@ -32,6 +32,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
saveNeededStore,
opacityStateStore,
} from "./store";
+ import { get } from "svelte/store";
import { drawEllipse, drawPolygon, drawRectangle, drawText } from "./tools/index";
import { makeMaskTransparent, SHAPE_MASK_COLOR } from "./tools/lib";
import { enableSelectable, stopDraw } from "./tools/lib";
@@ -55,6 +56,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
onWheelDragX,
} from "./tools/tool-zoom";
import { fillMask } from "./tools/tool-fill";
+ import { getCustomColours, saveCustomColours } from "@generated/backend";
export let canvas;
export let iconSize;
@@ -76,6 +78,16 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
let colourRef: HTMLInputElement | undefined;
const colour = writable(SHAPE_MASK_COLOR);
+ const customColorPickerPalette = writable([]);
+
+ async function loadCustomColours() {
+ customColorPickerPalette.set(
+ (await getCustomColours({})).colours.filter(
+ (hex) => !hex.startsWith("#ffffff"),
+ ),
+ );
+ }
+
function onClick(event: MouseEvent) {
const upperCanvas = document.querySelector(".upper-canvas");
if (event.target == upperCanvas) {
@@ -222,7 +234,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
}
onMount(() => {
- opacityStateStore.set(maskOpacity);
+ maskOpacity = get(opacityStateStore);
removeHandlers = singleCallback(
on(document, "click", onClick),
on(window, "mousemove", onMousemove),
@@ -233,6 +245,7 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
on(document, "touchstart", onTouchstart),
on(document, "mousemove", onMousemoveDocument),
);
+ loadCustomColours();
});
onDestroy(() => {
@@ -241,7 +254,10 @@ License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
($colour = e.currentTarget!.value)}
+ on:change={() => saveCustomColours({})}
/>
diff --git a/ts/routes/image-occlusion/add-or-update-note.svelte.ts b/ts/routes/image-occlusion/add-or-update-note.svelte.ts
index ce31eaaaf48..8494563b4a2 100644
--- a/ts/routes/image-occlusion/add-or-update-note.svelte.ts
+++ b/ts/routes/image-occlusion/add-or-update-note.svelte.ts
@@ -37,7 +37,9 @@ export const addOrUpdateNote = async function(
backExtra,
tags,
});
- showResult(mode.noteId, result, noteCount);
+ if (result.note) {
+ showResult(mode.noteId, result, noteCount);
+ }
} else {
const result = await addImageOcclusionNote({
// IOCloningMode is not used on mobile
@@ -55,23 +57,12 @@ export const addOrUpdateNote = async function(
// show toast message
const showResult = (noteId: number | null, result: OpChanges, count: number) => {
const props = $state({
- message: "",
- type: "error" as "error" | "success",
+ message: noteId ? tr.browsingCardsUpdated({ count: count }) : tr.importingCardsAdded({ count: count }),
+ type: "success" as "error" | "success",
showToast: true,
});
mount(Toast, {
target: document.body,
props,
});
-
- if (result.note) {
- const msg = noteId ? tr.browsingCardsUpdated({ count: count }) : tr.importingCardsAdded({ count: count });
- props.message = msg;
- props.type = "success";
- props.showToast = true;
- } else {
- const msg = tr.notetypesErrorGeneratingCloze();
- props.message = msg;
- props.showToast = true;
- }
};
diff --git a/ts/routes/image-occlusion/mask-editor.ts b/ts/routes/image-occlusion/mask-editor.ts
index 6d4d0d28430..41adbe42328 100644
--- a/ts/routes/image-occlusion/mask-editor.ts
+++ b/ts/routes/image-occlusion/mask-editor.ts
@@ -8,10 +8,22 @@ import { fabric } from "fabric";
import { get } from "svelte/store";
import { optimumCssSizeForCanvas } from "./canvas-scale";
-import { hideAllGuessOne, notesDataStore, saveNeededStore, tagsWritable, textEditingState } from "./store";
+import {
+ hideAllGuessOne,
+ notesDataStore,
+ opacityStateStore,
+ saveNeededStore,
+ tagsWritable,
+ textEditingState,
+} from "./store";
import Toast from "./Toast.svelte";
import { addShapesToCanvasFromCloze } from "./tools/add-from-cloze";
-import { enableSelectable, makeShapesRemainInCanvas, moveShapeToCanvasBoundaries } from "./tools/lib";
+import {
+ enableSelectable,
+ makeMaskTransparent,
+ makeShapesRemainInCanvas,
+ moveShapeToCanvasBoundaries,
+} from "./tools/lib";
import { modifiedPolygon } from "./tools/tool-polygon";
import { undoStack } from "./tools/tool-undo-redo";
import { enablePinchZoom, onResize, setCanvasSize } from "./tools/tool-zoom";
@@ -83,6 +95,7 @@ export const setupMaskEditorForEdit = async (
window.requestAnimationFrame(() => {
onImageLoaded({ noteId: BigInt(noteId) });
});
+ if (get(opacityStateStore)) { makeMaskTransparent(canvas, true); }
};
return canvas;
diff --git a/yarn.lock b/yarn.lock
index 84bd46e3147..bc1640152a3 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6939,8 +6939,8 @@ __metadata:
linkType: hard
"vite@npm:6":
- version: 6.3.5
- resolution: "vite@npm:6.3.5"
+ version: 6.4.1
+ resolution: "vite@npm:6.4.1"
dependencies:
esbuild: "npm:^0.25.0"
fdir: "npm:^6.4.4"
@@ -6989,7 +6989,7 @@ __metadata:
optional: true
bin:
vite: bin/vite.js
- checksum: 10c0/df70201659085133abffc6b88dcdb8a57ef35f742a01311fc56a4cfcda6a404202860729cc65a2c401a724f6e25f9ab40ce4339ed4946f550541531ced6fe41c
+ checksum: 10c0/77bb4c5b10f2a185e7859cc9a81c789021bc18009b02900347d1583b453b58e4b19ff07a5e5a5b522b68fc88728460bb45a63b104d969e8c6a6152aea3b849f7
languageName: node
linkType: hard