@navita/extraction 3.0.0-next.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Liljengård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+![Navita Logo](https://navita.style/navita.svg)
+
+Navita is a powerful CSS-in-JS library
+that brings type-safe compile-time Atomic CSS-in-JS with zero runtime to your projects.
+
+It allows you to easily style your components and apply themes without the need for any additional runtime dependencies.
+
+With Navita, you can write clean and maintainable CSS in JavaScript, without sacrificing runtime performance.
+
+
+🔥   All styles generated at build time — just like Sass, Less, etc.
+
+✨   Minimal abstraction over standard CSS.
+
+🦄   Works with any JS-based front-end framework — or even without one.
+
+🎨   High-level theme system with support for simultaneous themes.
+
+💪   Type-safe styles via [CSSType](https://github.com/frenic/csstype).
+
+🌳   Co-locate your styles with your components — if you want to.
+
+🛠   Integrations with popular bundlers such as Webpack, Vite, and Next.js.
+
+---
+🌐 [Check out the documentation site for setup guides, examples and API docs.](https://navita.style)
+
+---
+
+## Installation
+
+To start using Navita in your project, simply follow these steps:
+
+### Install Navita using npm:
+
+```bash
+npm install @navita/css --save
+```
+
+You'll also need to install the Navita integration for your preferred bundler.
+Navita currently supports Webpack, Vite, and Next.js.
+
+### Choose the integration for your preferred bundler:
+#### If you are using Webpack, install the Webpack integration:
+
+```bash
+npm install @navita/webpack-plugin mini-css-extract-plugin --save-dev
+```
+
+Update your `webpack.config.js` file to include both MiniCssExtractPlugin and NavitaPlugin:
+
+```javascript
+const { NavitaPlugin } = require('@navita/webpack-plugin');
+const MiniCssExtractPlugin = require('mini-css-extract-plugin');
+
+module.exports = {
+  // Other webpack options,
+  plugins: [
+    new MiniCssExtractPlugin(),
+    new NavitaPlugin(),
+  ],
+};
+```
+
+Read more about the Webpack integration in the [Webpack documentation](https://navita.style/integrations/webpack).
+
+#### If you are using Vite, install the Vite integration:
+
+```bash
+npm install @navita/vite-plugin --save-dev
+```
+
+And add it to your `vite.config.js` file:
+
+```typescript
+import { defineConfig } from 'vite';
+import { navita } from '@navita/vite-plugin';
+
+export default defineConfig({
+  plugins: [
+    // Other plugins
+    navita(/* Additional options */)
+  ],
+});
+```
+
+Read more about the Vite integration in the [Vite documentation](https://navita.style/integrations/vite).
+
+##### If you are using Next.js, install the Next.js integration:
+
+🚀   React Server Components support!
+
+```bash
+npm install @navita/next-plugin --save-dev
+```
+
+And add it to your `next.config.js` file:
+
+```javascript
+const { createNavitaStylePlugin } = require("@navita/next-plugin");
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+module.exports = createNavitaStylePlugin({
+  // Additional options
+})(nextConfig);
+```
+
+Read more about the Next.js integration in the [Next.js documentation](https://navita.style/integrations/next).
+
+## Usage
+
+The main entry point for Navita is the `style` function.
+Make sure you read the reset of the documentation on
+<https://navita.style> to learn more about the APIs.
+
+```typescript
+import { style } from '@navita/css';
+
+const container = style({
+  padding: '2rem',
+  background: 'hotpink',
+  color: 'white',
+});
+
+document.write(`
+  <div class="${container}">
+    Hello World!
+  </div>
+`);
+```
+
+That's it!
+
+💡 Only references to the classNames will be included in the bundle.
+
+> Note: Navita doesn't require special file extensions for your styles.
+You can co-locate your CSS styles with your components.
+
+## Documentation
+
+For detailed documentation, examples, and usage guidelines,
+please visit the official Navita website: <https://navita.style>
+
+## Contributing
+
+We welcome contributions from the community to make Navita even better!
+
+## Thanks
+* [Vanilla-Extract](https://vanilla-extract.style) and [Linaria](https://linaria.dev) for the inspiration and the great work on the CSS-in-JS ecosystem. 
+* [Fela](https://fela.js.org) for the fantastic work on Atomic css-in-js.
+* [Eagerpatch](https://eagerpatch.com) for giving us the space to do interesting work.
+***
+
+MIT Licensed—A project by [Eagerpatch](https://eagerpatch.com).\
+Made with ❤️ by [zn4rk](https://github.com/zn4rk) and contributors.

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,8 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require };

package/ast.cjs

@@ -0,0 +1,164 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/ast.ts
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"parent"
+]);
+/**
+* Recursively visit every child node. The callback may return `false` to skip
+* descending into that node's children.
+*/
+function walk(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) walk(child, visit);
+		return;
+	}
+	const n = node;
+	if (typeof n.type === "string") {
+		if (visit(n) === false) return;
+	}
+	for (const key in n) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = n[key];
+		if (value && typeof value === "object") walk(value, visit);
+	}
+}
+/** Unwrap `(expr)` parenthesized expressions. */
+function unwrapParens(node) {
+	let current = node;
+	while (current && current.type === "ParenthesizedExpression") current = current.expression;
+	return current ?? null;
+}
+/**
+* Return the callee identifier name of a call expression, if the callee is a
+* plain identifier (mirrors the Rust `get_callee_ident`). Member expressions
+* (`obj.style(...)`) return `null`.
+*/
+function getCalleeName(callExpr) {
+	const callee = unwrapParens(callExpr.callee);
+	if (callee && callee.type === "Identifier") return callee.name;
+	return null;
+}
+/**
+* If `expr` (after unwrapping parens) is a call expression whose callee is a
+* plain identifier, return that identifier name (mirrors `get_callee_ident` on
+* an init expression).
+*/
+function getInitCalleeName(expr) {
+	const inner = unwrapParens(expr);
+	if (inner && inner.type === "CallExpression") return getCalleeName(inner);
+	return null;
+}
+/**
+* Collect the binding identifier names introduced by a binding pattern.
+* Mirrors `collect_ids_from_pat`.
+*/
+function patternNames(pat, out = []) {
+	if (!pat) return out;
+	switch (pat.type) {
+		case "Identifier":
+		case "BindingIdentifier":
+			out.push(pat.name);
+			break;
+		case "AssignmentPattern":
+			patternNames(pat.left, out);
+			break;
+		case "ArrayPattern":
+			for (const element of pat.elements || []) if (element) patternNames(element, out);
+			break;
+		case "ObjectPattern":
+			for (const prop of pat.properties || []) if (prop.type === "RestElement") patternNames(prop.argument, out);
+			else patternNames(prop.value, out);
+			break;
+		case "RestElement":
+			patternNames(pat.argument, out);
+			break;
+		default: break;
+	}
+	return out;
+}
+/**
+* Collect identifier names referenced inside a value expression, applying the
+* same skipping rules as the Rust `IdentCollector`:
+*  - For member expressions, only descend into a computed property; never the
+*    static property name (`a.b` collects `a`, not `b`).
+*  - For object properties, only descend into a computed key; always the value
+*    (`{ key: value }` collects `value`, not `key`).
+*  - TypeScript type positions are skipped.
+*/
+function collectArgumentIdents(node, out) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectArgumentIdents(child, out);
+		return;
+	}
+	const n = node;
+	switch (n.type) {
+		case "Identifier":
+		case "IdentifierReference":
+			out.add(n.name);
+			return;
+		case "MemberExpression":
+		case "StaticMemberExpression":
+		case "ComputedMemberExpression":
+			if (n.computed) collectArgumentIdents(n.property, out);
+			collectArgumentIdents(n.object, out);
+			return;
+		case "Property":
+		case "ObjectProperty":
+			if (n.computed) collectArgumentIdents(n.key, out);
+			collectArgumentIdents(n.value, out);
+			return;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSInstantiationExpression":
+		case "TSTypeAssertion":
+			collectArgumentIdents(n.expression, out);
+			return;
+		default: break;
+	}
+	for (const key in n) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = n[key];
+		if (value && typeof value === "object") collectArgumentIdents(value, out);
+	}
+}
+/** Build a (1-based line, 0-based column) lookup for byte/UTF-16 offsets. */
+function createLineColumnLookup(code) {
+	const lineStarts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 1);
+	return (offset) => {
+		let lo = 0;
+		let hi = lineStarts.length - 1;
+		while (lo < hi) {
+			const mid = lo + hi + 1 >> 1;
+			if (lineStarts[mid] <= offset) lo = mid;
+			else hi = mid - 1;
+		}
+		return {
+			line: lo + 1,
+			column: offset - lineStarts[lo]
+		};
+	};
+}
+/** The imported name of a named import specifier (identifier or string key). */
+function importedName(spec) {
+	const imported = spec.imported;
+	if (!imported) return spec.local.name;
+	return imported.type === "Identifier" || imported.type === "ImportSpecifier" ? imported.name : imported.value;
+}
+//#endregion
+exports.collectArgumentIdents = collectArgumentIdents;
+exports.createLineColumnLookup = createLineColumnLookup;
+exports.getCalleeName = getCalleeName;
+exports.getInitCalleeName = getInitCalleeName;
+exports.importedName = importedName;
+exports.patternNames = patternNames;
+exports.unwrapParens = unwrapParens;
+exports.walk = walk;

package/ast.mjs

@@ -0,0 +1,159 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/ast.ts
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"parent"
+]);
+/**
+* Recursively visit every child node. The callback may return `false` to skip
+* descending into that node's children.
+*/
+function walk(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) walk(child, visit);
+		return;
+	}
+	const n = node;
+	if (typeof n.type === "string") {
+		if (visit(n) === false) return;
+	}
+	for (const key in n) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = n[key];
+		if (value && typeof value === "object") walk(value, visit);
+	}
+}
+/** Unwrap `(expr)` parenthesized expressions. */
+function unwrapParens(node) {
+	let current = node;
+	while (current && current.type === "ParenthesizedExpression") current = current.expression;
+	return current ?? null;
+}
+/**
+* Return the callee identifier name of a call expression, if the callee is a
+* plain identifier (mirrors the Rust `get_callee_ident`). Member expressions
+* (`obj.style(...)`) return `null`.
+*/
+function getCalleeName(callExpr) {
+	const callee = unwrapParens(callExpr.callee);
+	if (callee && callee.type === "Identifier") return callee.name;
+	return null;
+}
+/**
+* If `expr` (after unwrapping parens) is a call expression whose callee is a
+* plain identifier, return that identifier name (mirrors `get_callee_ident` on
+* an init expression).
+*/
+function getInitCalleeName(expr) {
+	const inner = unwrapParens(expr);
+	if (inner && inner.type === "CallExpression") return getCalleeName(inner);
+	return null;
+}
+/**
+* Collect the binding identifier names introduced by a binding pattern.
+* Mirrors `collect_ids_from_pat`.
+*/
+function patternNames(pat, out = []) {
+	if (!pat) return out;
+	switch (pat.type) {
+		case "Identifier":
+		case "BindingIdentifier":
+			out.push(pat.name);
+			break;
+		case "AssignmentPattern":
+			patternNames(pat.left, out);
+			break;
+		case "ArrayPattern":
+			for (const element of pat.elements || []) if (element) patternNames(element, out);
+			break;
+		case "ObjectPattern":
+			for (const prop of pat.properties || []) if (prop.type === "RestElement") patternNames(prop.argument, out);
+			else patternNames(prop.value, out);
+			break;
+		case "RestElement":
+			patternNames(pat.argument, out);
+			break;
+		default: break;
+	}
+	return out;
+}
+/**
+* Collect identifier names referenced inside a value expression, applying the
+* same skipping rules as the Rust `IdentCollector`:
+*  - For member expressions, only descend into a computed property; never the
+*    static property name (`a.b` collects `a`, not `b`).
+*  - For object properties, only descend into a computed key; always the value
+*    (`{ key: value }` collects `value`, not `key`).
+*  - TypeScript type positions are skipped.
+*/
+function collectArgumentIdents(node, out) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectArgumentIdents(child, out);
+		return;
+	}
+	const n = node;
+	switch (n.type) {
+		case "Identifier":
+		case "IdentifierReference":
+			out.add(n.name);
+			return;
+		case "MemberExpression":
+		case "StaticMemberExpression":
+		case "ComputedMemberExpression":
+			if (n.computed) collectArgumentIdents(n.property, out);
+			collectArgumentIdents(n.object, out);
+			return;
+		case "Property":
+		case "ObjectProperty":
+			if (n.computed) collectArgumentIdents(n.key, out);
+			collectArgumentIdents(n.value, out);
+			return;
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSInstantiationExpression":
+		case "TSTypeAssertion":
+			collectArgumentIdents(n.expression, out);
+			return;
+		default: break;
+	}
+	for (const key in n) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = n[key];
+		if (value && typeof value === "object") collectArgumentIdents(value, out);
+	}
+}
+/** Build a (1-based line, 0-based column) lookup for byte/UTF-16 offsets. */
+function createLineColumnLookup(code) {
+	const lineStarts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 1);
+	return (offset) => {
+		let lo = 0;
+		let hi = lineStarts.length - 1;
+		while (lo < hi) {
+			const mid = lo + hi + 1 >> 1;
+			if (lineStarts[mid] <= offset) lo = mid;
+			else hi = mid - 1;
+		}
+		return {
+			line: lo + 1,
+			column: offset - lineStarts[lo]
+		};
+	};
+}
+/** The imported name of a named import specifier (identifier or string key). */
+function importedName(spec) {
+	const imported = spec.imported;
+	if (!imported) return spec.local.name;
+	return imported.type === "Identifier" || imported.type === "ImportSpecifier" ? imported.name : imported.value;
+}
+//#endregion
+export { collectArgumentIdents, createLineColumnLookup, getCalleeName, getInitCalleeName, importedName, patternNames, unwrapParens, walk };

package/extraction.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rewrite = require("./rewrite.cjs");
+const require_stripTypes = require("./stripTypes.cjs");
+const require_toAmd = require("./toAmd.cjs");
+//#region src/extraction.ts
+/**
+* Transform a TypeScript/TSX module into an evaluatable AMD module for
+* `@navita/core`.
+*
+* For entry points, navita style calls are extracted into `collectResult(...)`
+* wrappers and the module is pruned to only what's needed to evaluate them.
+* For dependencies (`entryPoint: false`), the module is returned unchanged
+* except for TypeScript stripping and AMD wrapping.
+*/
+async function extraction(code, { filename, importMap = [], entryPoint = true }) {
+	if (entryPoint === false) return require_toAmd.esmToAmd(require_stripTypes.stripTypes(filename, code), { dropUnusedImports: false });
+	return require_toAmd.esmToAmd(require_stripTypes.stripTypes(filename, require_rewrite.rewrite(code, {
+		filename,
+		importMap
+	})), { dropUnusedImports: true });
+}
+//#endregion
+exports.extraction = extraction;

package/extraction.mjs

@@ -0,0 +1,25 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { rewrite } from "./rewrite.mjs";
+import { stripTypes } from "./stripTypes.mjs";
+import { esmToAmd } from "./toAmd.mjs";
+//#region src/extraction.ts
+/**
+* Transform a TypeScript/TSX module into an evaluatable AMD module for
+* `@navita/core`.
+*
+* For entry points, navita style calls are extracted into `collectResult(...)`
+* wrappers and the module is pruned to only what's needed to evaluate them.
+* For dependencies (`entryPoint: false`), the module is returned unchanged
+* except for TypeScript stripping and AMD wrapping.
+*/
+async function extraction(code, { filename, importMap = [], entryPoint = true }) {
+	if (entryPoint === false) return esmToAmd(stripTypes(filename, code), { dropUnusedImports: false });
+	return esmToAmd(stripTypes(filename, rewrite(code, {
+		filename,
+		importMap
+	})), { dropUnusedImports: true });
+}
+//#endregion
+export { extraction };

package/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_extraction = require("./extraction.cjs");
+exports.extraction = require_extraction.extraction;

package/index.d.ts

@@ -0,0 +1,24 @@
+import { ImportMap } from "@navita/types";
+
+//#region src/extraction.d.ts
+type Options = {
+  filename: string;
+  importMap?: ImportMap;
+  entryPoint?: boolean;
+};
+/**
+ * Transform a TypeScript/TSX module into an evaluatable AMD module for
+ * `@navita/core`.
+ *
+ * For entry points, navita style calls are extracted into `collectResult(...)`
+ * wrappers and the module is pruned to only what's needed to evaluate them.
+ * For dependencies (`entryPoint: false`), the module is returned unchanged
+ * except for TypeScript stripping and AMD wrapping.
+ */
+declare function extraction(code: string, {
+  filename,
+  importMap,
+  entryPoint
+}: Options): Promise<string>;
+//#endregion
+export { extraction };

package/index.mjs

@@ -0,0 +1,5 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { extraction } from "./extraction.mjs";
+export { extraction };

package/loadOxc.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/loadOxc.ts
+function getNativeRequire() {
+	const proc = process;
+	return (typeof process !== "undefined" && typeof proc.getBuiltinModule === "function" ? proc.getBuiltinModule("module") : require("node:module")).createRequire(__filename);
+}
+let parser;
+let transform;
+function getParser() {
+	if (!parser) parser = getNativeRequire()("oxc-parser");
+	return parser;
+}
+function getTransform() {
+	if (!transform) transform = getNativeRequire()("oxc-transform");
+	return transform;
+}
+//#endregion
+exports.getParser = getParser;
+exports.getTransform = getTransform;

package/loadOxc.mjs

@@ -0,0 +1,21 @@
+import "node:path";
+import __tsdown_shims_url from "node:url";
+const __TSDOWN_SHIM_FILENAME__ = /* @__PURE__ */ __tsdown_shims_url.fileURLToPath(import.meta.url);
+import { __require } from "./_virtual/_rolldown/runtime.mjs";
+//#region src/loadOxc.ts
+function getNativeRequire() {
+	const proc = process;
+	return (typeof process !== "undefined" && typeof proc.getBuiltinModule === "function" ? proc.getBuiltinModule("module") : __require("node:module")).createRequire(__TSDOWN_SHIM_FILENAME__);
+}
+let parser;
+let transform;
+function getParser() {
+	if (!parser) parser = getNativeRequire()("oxc-parser");
+	return parser;
+}
+function getTransform() {
+	if (!transform) transform = getNativeRequire()("oxc-transform");
+	return transform;
+}
+//#endregion
+export { getParser, getTransform };