qubu 0.0.0 → 0.3.3

package/dist/vite.d.mts

@@ -0,0 +1,35 @@
+//#region src/vite/globals.d.ts
+/**
+ * Public runtime names that the `"use qubu"` transform can auto-import.
+ * Keep this catalog aligned with the ordinary authoring surface of `qubu`;
+ * fragment internals, dialect construction, and schema extensions belong to
+ * the layered entrypoints.
+ */
+declare const qubuGlobals: readonly ["add", "alias", "all", "allowAll", "and", "asc", "asValue", "avg", "bigint", "between", "binary", "boolean", "call", "caseWhen", "cast", "check", "coalesce", "column", "concat", "count", "countDistinct", "correlate", "crossJoin", "cte", "date", "denseRank", "defaultValues", "deleteFrom", "desc", "distinct", "divide", "eq", "except", "execute", "executeRows", "externalDefault", "externalGeneratedColumn", "exists", "fetchFirst", "fetchNext", "foreignKey", "from", "fullJoin", "generatedColumn", "gt", "gte", "groupBy", "having", "identityColumn", "inList", "inQuery", "index", "innerJoin", "insertInto", "insertSelect", "integer", "intersect", "isDistinctFrom", "isNotDistinctFrom", "isNotNull", "isNull", "isTrue", "json", "jsonBoolean", "jsonExists", "jsonNumber", "jsonPath", "jsonText", "lateral", "leftJoin", "like", "lower", "lt", "lte", "max", "min", "modulo", "multiply", "naturalJoin", "nativeColumn", "nativeStorage", "ne", "not", "notExists", "notIn", "notLike", "nullsFirst", "nullsLast", "numeric", "nullable", "offset", "omit", "or", "order", "orderBy", "over", "portableStorage", "primaryKey", "qubu", "references", "recursiveCte", "render", "returning", "rightJoin", "rank", "rowNumber", "scalar", "schema", "schemaCall", "select", "sql", "stream", "subtract", "sum", "table", "text", "timestamp", "union", "unionAll", "unique", "uniqueConstraint", "update", "upper", "value", "values", "where", "withCte", "uuid"];
+type QubuGlobal = (typeof qubuGlobals)[number];
+//#endregion
+//#region src/vite/index.d.ts
+interface QubuVitePluginOptions {
+  /** Module specifier used for injected imports. @default "qubu" */
+  readonly module?: string;
+  /** Restrict transformation to matching module IDs. */
+  readonly include?: RegExp | ((id: string) => boolean);
+  /** Exclude matching module IDs. */
+  readonly exclude?: RegExp | ((id: string) => boolean);
+  /** Override the auto-importable public Qubu names. */
+  readonly globals?: readonly QubuGlobal[];
+}
+interface QubuViteTransformResult {
+  readonly code: string;
+  readonly map: null;
+}
+/** A Vite-compatible plugin without a runtime dependency on Vite itself. */
+interface QubuVitePlugin {
+  readonly name: 'qubu:compiler-hint';
+  readonly enforce: 'pre';
+  transform(code: string, id: string): QubuViteTransformResult | null;
+}
+declare function qubu(options?: QubuVitePluginOptions): QubuVitePlugin;
+declare const qubuVitePlugin: typeof qubu;
+//#endregion
+export { type QubuGlobal, QubuVitePlugin, QubuVitePluginOptions, QubuViteTransformResult, qubu as default, qubu, qubuGlobals, qubuVitePlugin };

package/dist/vite.mjs

@@ -0,0 +1,498 @@
+//#region src/vite/directive.ts
+function findQubuDirective(source) {
+	let cursor = skipTrivia(source, 0);
+	while (cursor < source.length && isQuote(source[cursor])) {
+		const literal = readString(source, cursor);
+		if (!literal) break;
+		let statementEnd = literal.end;
+		if (source[statementEnd] === ";") statementEnd += 1;
+		const next = skipTrivia(source, statementEnd);
+		if (literal.value === "use qubu") return { end: next };
+		if (next >= source.length || !isQuote(source[next])) break;
+		cursor = next;
+	}
+	return null;
+}
+function skipTrivia(source, start) {
+	let cursor = start;
+	while (cursor < source.length) {
+		if (isWhitespace$1(source[cursor])) {
+			cursor += 1;
+			continue;
+		}
+		if (source.startsWith("//", cursor)) {
+			const lineEnd = source.indexOf("\n", cursor + 2);
+			cursor = lineEnd === -1 ? source.length : lineEnd + 1;
+			continue;
+		}
+		if (source.startsWith("/*", cursor)) {
+			const commentEnd = source.indexOf("*/", cursor + 2);
+			cursor = commentEnd === -1 ? source.length : commentEnd + 2;
+			continue;
+		}
+		if (cursor === 0 && source.startsWith("#!", cursor)) {
+			const lineEnd = source.indexOf("\n", cursor + 2);
+			cursor = lineEnd === -1 ? source.length : lineEnd + 1;
+			continue;
+		}
+		break;
+	}
+	return cursor;
+}
+function readString(source, start) {
+	const quote = source[start];
+	let cursor = start + 1;
+	let value = "";
+	while (cursor < source.length) {
+		const character = source[cursor];
+		if (character === "\\") {
+			if (cursor + 1 >= source.length) return null;
+			value += source[cursor + 1];
+			cursor += 2;
+			continue;
+		}
+		if (character === quote) return {
+			value,
+			end: cursor + 1
+		};
+		if (character === "\n" || character === "\r") return null;
+		value += character;
+		cursor += 1;
+	}
+	return null;
+}
+function isQuote(character) {
+	return character === "'" || character === "\"";
+}
+function isWhitespace$1(character) {
+	return character !== void 0 && /\s/.test(character);
+}
+//#endregion
+//#region src/vite/globals.ts
+/**
+* Public runtime names that the `"use qubu"` transform can auto-import.
+* Keep this catalog aligned with the ordinary authoring surface of `qubu`;
+* fragment internals, dialect construction, and schema extensions belong to
+* the layered entrypoints.
+*/
+const qubuGlobals = [
+	"add",
+	"alias",
+	"all",
+	"allowAll",
+	"and",
+	"asc",
+	"asValue",
+	"avg",
+	"bigint",
+	"between",
+	"binary",
+	"boolean",
+	"call",
+	"caseWhen",
+	"cast",
+	"check",
+	"coalesce",
+	"column",
+	"concat",
+	"count",
+	"countDistinct",
+	"correlate",
+	"crossJoin",
+	"cte",
+	"date",
+	"denseRank",
+	"defaultValues",
+	"deleteFrom",
+	"desc",
+	"distinct",
+	"divide",
+	"eq",
+	"except",
+	"execute",
+	"executeRows",
+	"externalDefault",
+	"externalGeneratedColumn",
+	"exists",
+	"fetchFirst",
+	"fetchNext",
+	"foreignKey",
+	"from",
+	"fullJoin",
+	"generatedColumn",
+	"gt",
+	"gte",
+	"groupBy",
+	"having",
+	"identityColumn",
+	"inList",
+	"inQuery",
+	"index",
+	"innerJoin",
+	"insertInto",
+	"insertSelect",
+	"integer",
+	"intersect",
+	"isDistinctFrom",
+	"isNotDistinctFrom",
+	"isNotNull",
+	"isNull",
+	"isTrue",
+	"json",
+	"jsonBoolean",
+	"jsonExists",
+	"jsonNumber",
+	"jsonPath",
+	"jsonText",
+	"lateral",
+	"leftJoin",
+	"like",
+	"lower",
+	"lt",
+	"lte",
+	"max",
+	"min",
+	"modulo",
+	"multiply",
+	"naturalJoin",
+	"nativeColumn",
+	"nativeStorage",
+	"ne",
+	"not",
+	"notExists",
+	"notIn",
+	"notLike",
+	"nullsFirst",
+	"nullsLast",
+	"numeric",
+	"nullable",
+	"offset",
+	"omit",
+	"or",
+	"order",
+	"orderBy",
+	"over",
+	"portableStorage",
+	"primaryKey",
+	"qubu",
+	"references",
+	"recursiveCte",
+	"render",
+	"returning",
+	"rightJoin",
+	"rank",
+	"rowNumber",
+	"scalar",
+	"schema",
+	"schemaCall",
+	"select",
+	"sql",
+	"stream",
+	"subtract",
+	"sum",
+	"table",
+	"text",
+	"timestamp",
+	"union",
+	"unionAll",
+	"unique",
+	"uniqueConstraint",
+	"update",
+	"upper",
+	"value",
+	"values",
+	"where",
+	"withCte",
+	"uuid"
+];
+//#endregion
+//#region src/vite/tokens.ts
+const identifierStart = /[A-Za-z_$]/;
+const identifierPart = /[A-Za-z0-9_$]/;
+const punctuators = [
+	">>>=",
+	"===",
+	"!==",
+	"**=",
+	">>>",
+	"&&=",
+	"||=",
+	"??=",
+	"...",
+	"=>",
+	"?.",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"++",
+	"--",
+	"&&",
+	"||",
+	"??",
+	"**",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&=",
+	"|=",
+	"^=",
+	"<<",
+	">>"
+];
+function tokenize(source) {
+	const tokens = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const character = source[cursor];
+		if (isWhitespace(character)) {
+			cursor += 1;
+			continue;
+		}
+		if (source.startsWith("//", cursor)) {
+			cursor = skipLineComment(source, cursor);
+			continue;
+		}
+		if (source.startsWith("/*", cursor)) {
+			cursor = skipBlockComment(source, cursor);
+			continue;
+		}
+		if (character === "'" || character === "\"") {
+			cursor = skipQuotedString(source, cursor);
+			continue;
+		}
+		if (character === "`") {
+			cursor = skipTemplate(source, cursor);
+			continue;
+		}
+		if (isIdentifierStart(character)) {
+			const start = cursor;
+			cursor += 1;
+			while (cursor < source.length && isIdentifierPart(source[cursor])) cursor += 1;
+			tokens.push({
+				kind: "identifier",
+				value: source.slice(start, cursor),
+				start,
+				end: cursor
+			});
+			continue;
+		}
+		if (isNumberStart(character)) {
+			cursor = skipNumber(source, cursor);
+			continue;
+		}
+		const punctuator = punctuators.find((value) => source.startsWith(value, cursor));
+		if (punctuator) {
+			tokens.push({
+				kind: "punctuator",
+				value: punctuator,
+				start: cursor,
+				end: cursor + punctuator.length
+			});
+			cursor += punctuator.length;
+			continue;
+		}
+		tokens.push({
+			kind: "punctuator",
+			value: character,
+			start: cursor,
+			end: cursor + 1
+		});
+		cursor += 1;
+	}
+	return tokens;
+}
+function skipLineComment(source, start) {
+	const lineEnd = source.indexOf("\n", start + 2);
+	return lineEnd === -1 ? source.length : lineEnd + 1;
+}
+function skipBlockComment(source, start) {
+	const commentEnd = source.indexOf("*/", start + 2);
+	return commentEnd === -1 ? source.length : commentEnd + 2;
+}
+function skipQuotedString(source, start) {
+	const quote = source[start];
+	let cursor = start + 1;
+	while (cursor < source.length) {
+		if (source[cursor] === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (source[cursor] === quote) return cursor + 1;
+		cursor += 1;
+	}
+	return source.length;
+}
+function skipTemplate(source, start) {
+	let cursor = start + 1;
+	while (cursor < source.length) {
+		if (source[cursor] === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (source[cursor] === "`") return cursor + 1;
+		cursor += 1;
+	}
+	return source.length;
+}
+function skipNumber(source, start) {
+	let cursor = start;
+	while (cursor < source.length && /[A-Za-z0-9._]/.test(source[cursor])) cursor += 1;
+	return cursor;
+}
+function isIdentifierStart(character) {
+	return character !== void 0 && identifierStart.test(character);
+}
+function isIdentifierPart(character) {
+	return character !== void 0 && identifierPart.test(character);
+}
+function isNumberStart(character) {
+	return character !== void 0 && /[0-9]/.test(character);
+}
+function isWhitespace(character) {
+	return character !== void 0 && /\s/.test(character);
+}
+//#endregion
+//#region src/vite/references.ts
+function findQubuReferences(source, globals) {
+	const tokens = tokenize(source);
+	const available = new Set(globals);
+	const boundNames = collectBoundNames(tokens);
+	const used = /* @__PURE__ */ new Set();
+	for (const [index, token] of tokens.entries()) {
+		if (token.kind !== "identifier") continue;
+		if (!available.has(token.value)) continue;
+		if (boundNames.has(token.value)) continue;
+		if (!isReference(tokens, index)) continue;
+		used.add(token.value);
+	}
+	return globals.filter((name) => used.has(name));
+}
+function collectBoundNames(tokens) {
+	const boundNames = /* @__PURE__ */ new Set();
+	for (let index = 0; index < tokens.length; index += 1) {
+		const value = tokens[index].value;
+		if (value === "import") {
+			collectImportBindings(tokens, index, boundNames);
+			continue;
+		}
+		if (value === "const" || value === "let" || value === "var") {
+			collectVariableBinding(tokens, index + 1, boundNames);
+			continue;
+		}
+		if (value === "function" || value === "class" || value === "interface" || value === "type" || value === "enum" || value === "namespace") {
+			addNextIdentifier(tokens, index + 1, boundNames);
+			if (value === "function") collectParameterBindings(tokens, index + 1, boundNames);
+			continue;
+		}
+		if (value === "catch") {
+			collectParameterBindings(tokens, index + 1, boundNames);
+			continue;
+		}
+		if (value === "=>") {
+			const previous = tokens[index - 1];
+			if (previous?.kind === "identifier") boundNames.add(previous.value);
+			else if (previous?.value === ")") {
+				const opening = findMatchingOpening(tokens, index - 1, "(", ")");
+				if (opening !== -1) collectIdentifiers(tokens, opening + 1, index - 1, boundNames);
+			}
+		}
+	}
+	return boundNames;
+}
+function collectImportBindings(tokens, importIndex, boundNames) {
+	const next = tokens[importIndex + 1];
+	if (!next || next.value === "(" || next.value === ".") return;
+	for (let index = importIndex + 1; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (token.value === "from" || token.value === ";") break;
+		if (token.kind === "identifier" && token.value !== "type") boundNames.add(token.value);
+	}
+}
+function collectVariableBinding(tokens, start, boundNames) {
+	const first = tokens[start];
+	if (!first) return;
+	if (first.kind === "identifier") {
+		boundNames.add(first.value);
+		return;
+	}
+	if (first.value !== "{" && first.value !== "[") return;
+	const closing = findMatchingClosing(tokens, start);
+	if (closing !== -1) collectIdentifiers(tokens, start + 1, closing, boundNames);
+}
+function collectParameterBindings(tokens, start, boundNames) {
+	const opening = tokens.findIndex((token, index) => index >= start && token.value === "(");
+	if (opening === -1) return;
+	const closing = findMatchingClosing(tokens, opening);
+	if (closing !== -1) collectIdentifiers(tokens, opening + 1, closing, boundNames);
+}
+function collectIdentifiers(tokens, start, end, boundNames) {
+	for (let index = start; index < end; index += 1) {
+		const token = tokens[index];
+		if (token.kind === "identifier" && token.value !== "as") boundNames.add(token.value);
+	}
+}
+function addNextIdentifier(tokens, start, boundNames) {
+	const token = tokens[start];
+	if (token?.kind === "identifier") boundNames.add(token.value);
+}
+function isReference(tokens, index) {
+	const previous = tokens[index - 1]?.value;
+	const next = tokens[index + 1]?.value;
+	if (previous === "." || previous === "?." || previous === "#") return false;
+	if (next === ":") return false;
+	if (previous === "interface" || previous === "type") return false;
+	return true;
+}
+function findMatchingClosing(tokens, opening) {
+	const open = tokens[opening]?.value;
+	return findMatchingOpening(tokens, opening, open, open === "{" ? "}" : open === "[" ? "]" : ")", true);
+}
+function findMatchingOpening(tokens, start, open, close, forward = false) {
+	let depth = 0;
+	const step = forward ? 1 : -1;
+	const end = forward ? tokens.length : -1;
+	for (let index = start; index !== end; index += step) {
+		if (tokens[index].value === open) depth += 1;
+		if (tokens[index].value === close) depth -= 1;
+		if (depth === 0) return index;
+	}
+	return -1;
+}
+//#endregion
+//#region src/vite/index.ts
+const scriptExtension = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
+function qubu(options = {}) {
+	const moduleId = options.module ?? "qubu";
+	const globals = options.globals ?? qubuGlobals;
+	return {
+		name: "qubu:compiler-hint",
+		enforce: "pre",
+		transform(code, id) {
+			const filename = id.split("?", 1)[0];
+			if (!scriptExtension.test(filename)) return null;
+			if (filename.includes("/node_modules/")) return null;
+			if (options.include && !matches(options.include, id)) return null;
+			if (options.exclude && matches(options.exclude, id)) return null;
+			const directive = findQubuDirective(code);
+			if (!directive) return null;
+			const references = findQubuReferences(code, globals);
+			if (references.length === 0) return null;
+			const imports = `import { ${references.join(", ")} } from ${JSON.stringify(moduleId)};\n`;
+			return {
+				code: `${code.slice(0, directive.end)}${imports}${code.slice(directive.end)}`,
+				map: null
+			};
+		}
+	};
+}
+const qubuVitePlugin = qubu;
+function matches(filter, id) {
+	if (typeof filter === "function") return filter(id);
+	filter.lastIndex = 0;
+	return filter.test(id);
+}
+//#endregion
+export { qubu as default, qubu, qubuGlobals, qubuVitePlugin };

package/docs/config.json

@@ -0,0 +1,21 @@
+{
+  "link": {
+    "underline": "hover"
+  },
+  "reference": {
+    "enabled": false
+  },
+  "navigation": {
+    "order": [
+      "getting-started.md",
+      "query-model/",
+      "schema/",
+      "dialects-and-execution.md",
+      "sql-semantic-types.md",
+      "guides/",
+      "reference/",
+      "troubleshooting.md"
+    ],
+    "duration": 125
+  }
+}