@lapis-notes/api 0.1.0

package/dist/search-query/index.js

@@ -0,0 +1,426 @@
+import { LRLanguage, LanguageSupport } from "@codemirror/language";
+import { styleTags, tags } from "@lezer/highlight";
+import { parser } from "./parser";
+const configuredParser = parser.configure({
+    props: [
+        styleTags({
+            OrKeyword: tags.keyword,
+            NullKeyword: tags.atom,
+            Negation: tags.operator,
+            Word: tags.variableName,
+            SlashWord: tags.variableName,
+            Identifier: tags.variableName,
+            FieldName: tags.attributeName,
+            "FieldName/Identifier": tags.attributeName,
+            PropertyName: tags.propertyName,
+            "PropertyName/Identifier": tags.propertyName,
+            "PropertyName/Phrase": tags.propertyName,
+            ComparisonOperator: tags.operator,
+            Phrase: tags.string,
+            Regex: tags.regexp,
+            "( )": tags.bracket,
+            "[ ]": tags.bracket,
+            ":": tags.punctuation,
+        }),
+    ],
+});
+export const searchQueryParser = configuredParser;
+export const searchQueryLanguage = LRLanguage.define({
+    parser: configuredParser,
+    languageData: {
+        closeBrackets: {
+            brackets: ["(", "[", '"', "/"],
+        },
+    },
+});
+export function searchQueryLanguageSupport() {
+    return new LanguageSupport(searchQueryLanguage);
+}
+const SAFE_SEARCH_QUERY_WORD = /^[A-Za-z0-9_.#*?][A-Za-z0-9_.#*?/]*$/u;
+const SAFE_SEARCH_QUERY_IDENTIFIER = /^[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)*$/u;
+const RESERVED_SEARCH_QUERY_WORDS = new Set(["OR", "null"]);
+/** Formats a dynamic field value so it round-trips through the search parser. */
+export function formatSearchQueryValue(value) {
+    if (!RESERVED_SEARCH_QUERY_WORDS.has(value) &&
+        (SAFE_SEARCH_QUERY_WORD.test(value) ||
+            SAFE_SEARCH_QUERY_IDENTIFIER.test(value))) {
+        return value;
+    }
+    return `"${value
+        .replaceAll("\\", "\\\\")
+        .replaceAll('"', '\\"')
+        .replaceAll("\n", "\\n")
+        .replaceAll("\r", "\\r")
+        .replaceAll("\t", "\\t")}"`;
+}
+/** Builds the shared, parser-safe field catalog for vault search surfaces. */
+export function createVaultSearchFilterSyntax({ fileNames, paths, tags: tagValues, }) {
+    const values = (items) => [...new Set(items)]
+        .sort((left, right) => left.localeCompare(right))
+        .slice(0, 100)
+        .map((value) => ({ value, apply: formatSearchQueryValue(value) }));
+    return {
+        title: "Vault search syntax",
+        description: "Combine text with file, path, tag, content, line, section, and bracket-property filters.",
+        fields: [
+            {
+                name: "file",
+                description: "File name",
+                operators: [":"],
+                values: values(fileNames),
+            },
+            {
+                name: "path",
+                description: "Folder or path",
+                operators: [":"],
+                values: values(paths),
+            },
+            {
+                name: "tag",
+                description: "Markdown or frontmatter tag",
+                operators: [":"],
+                values: values(tagValues),
+            },
+            { name: "content", description: "Note content", operators: [":"] },
+            { name: "line", description: "Terms on one line", operators: [":"] },
+            {
+                name: "section",
+                description: "Terms in one section",
+                operators: [":"],
+            },
+        ],
+        examples: [
+            { query: "tag:#project", description: "Notes with a project tag" },
+            {
+                query: 'path:"Notes" OR file:Welcome',
+                description: "Path or file filters",
+            },
+            { query: '["status"]:ready', description: "Exact frontmatter property" },
+        ],
+        notes: ["Use OR for alternatives and -term to exclude a term."],
+    };
+}
+export function parseSearchQuery(input) {
+    return configuredParser.parse(input);
+}
+export function parseSearchQueryAst(input) {
+    const tree = parseSearchQuery(input);
+    const syntax = snapshotSearchQueryNode(tree.cursor(), input);
+    return {
+        type: "query",
+        from: 0,
+        to: input.length,
+        text: input,
+        expression: lowerSearchQueryNode(findChild(syntax, "Expression")),
+        diagnostics: collectSearchQueryDiagnostics(syntax, input),
+    };
+}
+export function canCollectSearchQueryTerms(value) {
+    const expression = unwrapSearchQueryExpression(value);
+    if (!expression) {
+        return value?.type === "query" ? value.diagnostics.length === 0 : true;
+    }
+    if (value?.type === "query" && value.diagnostics.length > 0) {
+        return false;
+    }
+    switch (expression.type) {
+        case "literal":
+            return expression.kind === "word" || expression.kind === "phrase";
+        case "property":
+            return expression.value === null;
+        case "group":
+            return expression.expression === null
+                ? true
+                : canCollectSearchQueryTerms(expression.expression);
+        case "and":
+            return expression.clauses.every((clause) => canCollectSearchQueryTerms(clause));
+        default:
+            return false;
+    }
+}
+export function collectSearchQueryTerms(value) {
+    const root = typeof value === "string" ? parseSearchQueryAst(value) : value;
+    const expression = unwrapSearchQueryExpression(root);
+    if (!canCollectSearchQueryTerms(root)) {
+        return [];
+    }
+    return collectSearchQueryTermValues(expression);
+}
+export function canCollectSearchQueryPropertyNames(value) {
+    const expression = unwrapSearchQueryExpression(value);
+    if (!expression) {
+        return value?.type === "query" ? value.diagnostics.length === 0 : true;
+    }
+    if (value?.type === "query" && value.diagnostics.length > 0) {
+        return false;
+    }
+    switch (expression.type) {
+        case "property":
+            return expression.value === null;
+        case "group":
+            return expression.expression === null
+                ? true
+                : canCollectSearchQueryPropertyNames(expression.expression);
+        case "and":
+            return expression.clauses.every((clause) => canCollectSearchQueryPropertyNames(clause));
+        case "literal":
+            return expression.kind === "word" || expression.kind === "phrase";
+        default:
+            return false;
+    }
+}
+export function collectSearchQueryPropertyNames(value) {
+    const root = typeof value === "string" ? parseSearchQueryAst(value) : value;
+    const expression = unwrapSearchQueryExpression(root);
+    if (!canCollectSearchQueryPropertyNames(root)) {
+        return [];
+    }
+    return collectSearchQueryPropertyNameValues(expression);
+}
+function snapshotSearchQueryNode(cursor, input) {
+    const node = {
+        name: cursor.name,
+        from: cursor.from,
+        to: cursor.to,
+        text: input.slice(cursor.from, cursor.to),
+        isError: cursor.name === "⚠" || cursor.type.isError,
+        children: [],
+    };
+    if (cursor.firstChild()) {
+        do {
+            node.children.push(snapshotSearchQueryNode(cursor, input));
+        } while (cursor.nextSibling());
+        cursor.parent();
+    }
+    return node;
+}
+function collectSearchQueryDiagnostics(node, input, insideError = false) {
+    const diagnostics = [];
+    if (node.isError && !insideError) {
+        diagnostics.push({
+            from: node.from,
+            to: node.to,
+            severity: "error",
+            message: formatSearchQueryDiagnosticMessage(node, input),
+            text: node.text,
+        });
+    }
+    for (const child of node.children) {
+        diagnostics.push(...collectSearchQueryDiagnostics(child, input, insideError || node.isError));
+    }
+    return diagnostics;
+}
+function formatSearchQueryDiagnosticMessage(node, input) {
+    const token = node.text.trim();
+    if (!token.length) {
+        return node.from >= input.length
+            ? "Incomplete search query"
+            : "Invalid search query syntax";
+    }
+    return `Unexpected token ${JSON.stringify(token)}`;
+}
+function lowerSearchQueryNode(node) {
+    if (!node)
+        return null;
+    switch (node.name) {
+        case "Expression":
+        case "PrimaryExpression":
+        case "FieldValue":
+        case "PropertyValue":
+        case "ComparisonValue":
+            return lowerFirstExpressionChild(node);
+        case "OrExpression":
+            return lowerClauseSequence(node, "AndExpression", "or", "clauses");
+        case "AndExpression":
+            return lowerClauseSequence(node, "PrefixExpression", "and", "clauses");
+        case "PrefixExpression": {
+            const operand = lowerSearchQueryNode(findChild(node, "PrimaryExpression"));
+            if (!findChild(node, "Negation")) {
+                return operand;
+            }
+            return {
+                type: "not",
+                operand,
+                ...nodeRange(node),
+            };
+        }
+        case "Group":
+            return {
+                type: "group",
+                expression: lowerSearchQueryNode(findChild(node, "Expression")),
+                ...nodeRange(node),
+            };
+        case "FieldExpression":
+            return {
+                type: "field",
+                name: readIdentifier(findChild(node, "FieldName")),
+                value: lowerSearchQueryNode(findChild(node, "FieldValue")),
+                ...nodeRange(node),
+            };
+        case "PropertyExpression":
+            return {
+                type: "property",
+                name: readPropertyName(findChild(node, "PropertyName")),
+                value: lowerSearchQueryNode(findChild(node, "PropertyValue")),
+                ...nodeRange(node),
+            };
+        case "Comparison":
+            return {
+                type: "comparison",
+                operator: readComparisonOperator(findChild(node, "ComparisonOperator")),
+                value: lowerSearchQueryLiteral(findChild(node, "ComparisonValue")),
+                ...nodeRange(node),
+            };
+        case "SlashWord":
+        case "Word":
+        case "Identifier":
+            return {
+                type: "literal",
+                kind: "word",
+                value: node.text,
+                ...nodeRange(node),
+            };
+        case "Phrase":
+            return {
+                type: "literal",
+                kind: "phrase",
+                value: decodeSearchQueryPhrase(node.text),
+                ...nodeRange(node),
+            };
+        case "Regex":
+            return {
+                type: "literal",
+                kind: "regex",
+                value: stripSearchQueryDelimiter(node.text),
+                ...nodeRange(node),
+            };
+        case "NullKeyword":
+            return {
+                type: "literal",
+                kind: "null",
+                value: null,
+                ...nodeRange(node),
+            };
+        default:
+            return lowerFirstExpressionChild(node);
+    }
+}
+function lowerClauseSequence(node, childName, type, key) {
+    const clauses = node.children
+        .filter((child) => child.name === childName)
+        .map((child) => lowerSearchQueryNode(child))
+        .filter((child) => child !== null);
+    if (!clauses.length)
+        return null;
+    if (clauses.length === 1)
+        return clauses[0];
+    return {
+        type,
+        [key]: clauses,
+        ...nodeRange(node),
+    };
+}
+function lowerFirstExpressionChild(node) {
+    for (const child of node.children) {
+        const lowered = lowerSearchQueryNode(child);
+        if (lowered) {
+            return lowered;
+        }
+    }
+    return null;
+}
+function lowerSearchQueryLiteral(node) {
+    const lowered = lowerSearchQueryNode(node);
+    if (lowered?.type === "literal") {
+        return lowered;
+    }
+    return null;
+}
+function findChild(node, name) {
+    return node.children.find((child) => child.name === name);
+}
+function readIdentifier(node) {
+    if (!node)
+        return "";
+    const identifier = findChild(node, "Identifier");
+    return (identifier ?? node).text;
+}
+function readPropertyName(node) {
+    if (!node)
+        return "";
+    const phrase = findChild(node, "Phrase");
+    if (phrase) {
+        return decodeSearchQueryPhrase(phrase.text);
+    }
+    return readIdentifier(node);
+}
+function readComparisonOperator(node) {
+    const value = node?.text;
+    if (value === "<" || value === "<=" || value === ">" || value === ">=") {
+        return value;
+    }
+    return "<";
+}
+function stripSearchQueryDelimiter(value) {
+    if (value.length < 2)
+        return value;
+    return value.slice(1, -1);
+}
+function decodeSearchQueryPhrase(value) {
+    return stripSearchQueryDelimiter(value).replace(/\\(["\\nrt])/gu, (_match, escaped) => {
+        switch (escaped) {
+            case "n":
+                return "\n";
+            case "r":
+                return "\r";
+            case "t":
+                return "\t";
+            default:
+                return escaped;
+        }
+    });
+}
+function nodeRange(node) {
+    return {
+        from: node.from,
+        to: node.to,
+        text: node.text,
+    };
+}
+function unwrapSearchQueryExpression(value) {
+    if (!value)
+        return null;
+    return value.type === "query" ? value.expression : value;
+}
+function collectSearchQueryTermValues(expression) {
+    if (!expression)
+        return [];
+    switch (expression.type) {
+        case "literal":
+            return expression.value ? [expression.value.toLowerCase()] : [];
+        case "property":
+            return expression.value === null ? [expression.name.toLowerCase()] : [];
+        case "group":
+            return collectSearchQueryTermValues(expression.expression);
+        case "and":
+            return expression.clauses.flatMap((clause) => collectSearchQueryTermValues(clause));
+        default:
+            return [];
+    }
+}
+function collectSearchQueryPropertyNameValues(expression) {
+    if (!expression)
+        return [];
+    switch (expression.type) {
+        case "property":
+            return expression.value === null ? [expression.name.toLowerCase()] : [];
+        case "group":
+            return collectSearchQueryPropertyNameValues(expression.expression);
+        case "and":
+            return expression.clauses.flatMap((clause) => collectSearchQueryPropertyNameValues(clause));
+        case "literal":
+            return [];
+        default:
+            return [];
+    }
+}

package/dist/search-query/parser.d.ts

@@ -0,0 +1,3 @@
+import type { LRParser } from "@lezer/lr";
+
+export const parser: LRParser;

package/dist/search-query/parser.js

@@ -0,0 +1,16 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+import {LRParser} from "@lezer/lr"
+export const parser = LRParser.deserialize({
+  version: 14,
+  states: "%pQVQPOOOtQPO'#CdO{QPO'#CfO!vQPO'#CiO#OQPO'#CeOOQO'#Cc'#CcOOQO'#Ca'#CaOYQPO'#CaOOQO'#Cu'#CuO#TQPO'#C`O#bQPO'#C_OOQO'#C^'#C^QOQPOOOOQO,59O,59OO#mQPO,59OOOQO'#Cj'#CjO#rQPO,59TO#zQPO,59POOQO,58{,58{OOQO-E6s-E6sOVQPO'#CvO$fQPO,58yOOQO1G.j1G.jO$qQPO1G.oO%lQPO1G.oOOQO'#Ch'#ChOOQO1G.k1G.kOOQO,59b,59bOOQO-E6t-E6tO%lQPO7+$ZO&WQPO'#CmOOQO'#Cl'#ClO&iQPO7+$ZOOQO<<Gu<<GuOOQO'#Co'#CoOOQO,59X,59X",
+  stateData: "&v~OmOS~OUVOZQO_TOdTOeTOfTOgTOnPOqRO~Oo]O~PVOUVXZVX_VXdVXeVXfVXgVXhVXkVXnVXpYXqVXoVX~OZ_O__O~OpaO~OhSXkSXoSX~PVOhdOkRXoRX~OofO~OphOrgO~OZiO_iOdiOeiOfiOgiOnPOqRO~OhdOkRaoRa~OpmOU]iZ]i_]id]ie]if]ig]ih]ik]in]iq]io]i~OZoO_oObnOdoOeoOfoOgoOnPO~OZrO_rOdrOerOfrO~OrqO~OhdeZbfZ~",
+  goto: "#skPPlrv}P!T!^!l!sP!z!}#XP#[!hP#bPPPPP#e#mQ[OR^PTZOPSYOPRkdXWOPXdWUOPXdRbVYTOPVXdQiaTohmZTOPVXdZSOPVXdRjaYTOPVXdRiaR`RQphRqmRsnUXOPdRcXQeYRle",
+  nodeNames: "⚠ Query Expression OrExpression AndExpression PrefixExpression Negation PrimaryExpression Group FieldExpression FieldName Identifier FieldValue PropertyExpression PropertyName Phrase PropertyValue Comparison ComparisonOperator ComparisonValue NullKeyword SlashWord Word Regex OrKeyword",
+  maxTerm: 34,
+  skippedNodes: [0],
+  repeatNodeCount: 2,
+  tokenData: "2}~RpX^#Vpq#Vrs#zst&sxy(Xyz(^z{&s}!O(c!O!P&s!P!Q(h!Q![+a![!],{!^!_-Q!`!a-Q!a!b&s!c!q+a!q!r-_!r!}+a!}#O/T#P#Q/Y#R#S+a#T#b+a#b#c/_#c#o+a#y#z#V$f$g#V#BY#BZ#V$IS$I_#V$I|$JO#V$JT$JU#V$KV$KW#V&FU&FV#V~#[Ym~X^#Vpq#V#y#z#V$f$g#V#BY#BZ#V$IS$I_#V$I|$JO#V$JT$JU#V$KV$KW#V&FU&FV#V~#}XOY#zZ]#z^r#zrs$js#O#z#O#P$o#P;'S#z;'S;=`&m<%lO#z~$oO_~~$rmOX#zX^#z^p#zpq#zq!Q#z!Q![#z![!c#z!c!}#z!}#T#z#T#o#z#o#y#z#y#z#z#z$f#z$f$g#z$g#BY#z#BY#BZ#z#BZ$IS#z$IS$I_#z$I_$I|#z$I|$JO#z$JO$JT#z$JT$JU#z$JU$KV#z$KV$KW#z$KW&FU#z&FU&FV#z&FV;'S#z;'S;=`&m<%lO#z~&pP;=`<%l#z~&xXf~st&sz{&s!O!P&s!P!Q'e!Q![&s!a!b&s!c!}&s#R#S&s#T#o&s~'lXe~f~st'ez{'e!O!P'e!P!Q'e!Q!['e!a!b'e!c!}'e#R#S'e#T#o'e~(^On~~(cOo~~(hOU~~(kXOY(hZ](h^!P(h!P!Q)W!Q#O(h#O#P)]#P;'S(h;'S;=`+Z<%lO(h~)]Og~~)`mOX(hX^(h^p(hpq(hq!Q(h!Q![(h![!c(h!c!}(h!}#T(h#T#o(h#o#y(h#y#z(h#z$f(h$f$g(h$g#BY(h#BY#BZ(h#BZ$IS(h$IS$I_(h$I_$I|(h$I|$JO(h$JO$JT(h$JT$JU(h$JU$KV(h$KV$KW(h$KW&FU(h&FU&FV(h&FV;'S(h;'S;=`+Z<%lO(h~+^P;=`<%l(h~+hYZ~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#o+a~,ZS!Q![,g!c!},g#R#S,g#T#o,g~,lTZ~}!O,W!Q![,g!c!},g#R#S,g#T#o,g~-QOp~~-VPb~!_!`-Y~-_Ob~~-f[Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!t+a!t!u.[!u!}+a#R#S+a#T#o+a~.eYh~Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#o+a~/YOq~~/_Or~~/f[Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#i+a#i#j0[#j#o+a~0c[Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#`+a#`#a1X#a#o+a~1`[Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#`+a#`#a2U#a#o+a~2_Yd~Z~f~st&sz{&s}!O,W!O!P&s!P!Q'e!Q![+a!a!b&s!c!}+a#R#S+a#T#o+a",
+  tokenizers: [0],
+  topRules: {"Query":[0,1]},
+  tokenPrec: 260
+})

package/dist/search-query/parser.terms.js

@@ -0,0 +1,26 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+export const
+  Query = 1,
+  Expression = 2,
+  OrExpression = 3,
+  AndExpression = 4,
+  PrefixExpression = 5,
+  Negation = 6,
+  PrimaryExpression = 7,
+  Group = 8,
+  FieldExpression = 9,
+  FieldName = 10,
+  Identifier = 11,
+  FieldValue = 12,
+  PropertyExpression = 13,
+  PropertyName = 14,
+  Phrase = 15,
+  PropertyValue = 16,
+  Comparison = 17,
+  ComparisonOperator = 18,
+  ComparisonValue = 19,
+  NullKeyword = 20,
+  SlashWord = 21,
+  Word = 22,
+  Regex = 23,
+  OrKeyword = 24

package/dist/search-query/search-query.grammar

@@ -0,0 +1,128 @@
+@top Query { Expression? }
+
+@skip { space }
+
+Expression { OrExpression }
+
+OrExpression {
+  AndExpression (OrKeyword AndExpression)*
+}
+
+AndExpression {
+  PrefixExpression+
+}
+
+PrefixExpression {
+  Negation? PrimaryExpression
+}
+
+PrimaryExpression {
+  Group |
+  FieldExpression |
+  PropertyExpression |
+  Regex |
+  Phrase |
+  NullKeyword |
+  SlashWord |
+  Identifier |
+  Word
+}
+
+Group {
+  "(" Expression? ")"
+}
+
+FieldExpression {
+  FieldName ":" FieldValue
+}
+
+FieldName {
+  Identifier
+}
+
+FieldValue {
+  Group |
+  PropertyExpression |
+  Regex |
+  Phrase |
+  NullKeyword |
+  SlashWord |
+  Identifier |
+  Word
+}
+
+PropertyExpression {
+  "[" PropertyName "]" |
+  "[" PropertyName "]" ":" PropertyValue |
+  "[" PropertyName ":" PropertyValue "]"
+}
+
+PropertyName {
+  Identifier |
+  Phrase
+}
+
+PropertyValue {
+  Comparison |
+  Group |
+  Regex |
+  Phrase |
+  NullKeyword |
+  SlashWord |
+  Identifier |
+  Word
+}
+
+Comparison {
+  ComparisonOperator ComparisonValue
+}
+
+ComparisonValue {
+  Phrase |
+  NullKeyword |
+  SlashWord |
+  Identifier |
+  Word
+}
+
+@tokens {
+  space { @whitespace+ }
+
+  @precedence {
+    OrKeyword,
+    NullKeyword,
+    SlashWord,
+    Identifier,
+    ComparisonOperator,
+    Word
+  }
+
+  OrKeyword { "OR" }
+  NullKeyword { "null" }
+  Negation { "-" }
+
+  Identifier { identifierChar+ ("-" identifierChar+)* }
+
+  ComparisonOperator { "<=" | ">=" | "<" | ">" }
+
+  SlashWord { wordStartChar wordChar* "/" wordChar* }
+  Word { wordStartChar wordChar* }
+
+  Phrase { '"' phraseChar* '"' }
+  Regex { "/" regexChar* "/" }
+
+  identifierChar { @asciiLetter | @digit | "_" }
+  wordStartChar {
+    @asciiLetter |
+    @digit |
+    "_" |
+    "." |
+    "#" |
+    "*" |
+    "?"
+  }
+  wordChar { wordStartChar | "/" }
+  phraseChar { !["\\\n\r] | "\\" anyChar }
+  regexChar { ![/\\\n\r] | "\\" anyChar }
+  anyChar { @asciiLetter | @digit | @whitespace | ![] }
+}

package/dist/search.d.ts

@@ -0,0 +1,19 @@
+export type SearchMatchPart = [start: number, end: number];
+export type SearchMatches = SearchMatchPart[];
+export interface SearchResult {
+    score: number;
+    matches: SearchMatches;
+}
+export interface SearchResultContainer {
+    score?: number;
+    result?: SearchResult;
+}
+export interface FuzzyMatch<T> {
+    item: T;
+    match: SearchResult;
+}
+export declare function prepareSimpleSearch(query: string): (text: string) => SearchResult | null;
+export declare function prepareFuzzySearch(query: string): (text: string) => SearchResult | null;
+export declare function renderMatches(el: HTMLElement | DocumentFragment, text: string, matches: SearchMatches | null, offset?: number): void;
+export declare function renderResults(el: HTMLElement, text: string, result: SearchResult, offset?: number): void;
+export declare function sortSearchResults(results: SearchResultContainer[]): void;