@gtkx/config 0.21.0 → 1.0.0-rc.1

package/src/element-props.ts

@@ -0,0 +1,248 @@
+import { z } from "zod";
+
+const ARG_REFS = ["child", "item", "index", "sibling", "adopted"] as const;
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+
+/**
+ * Named reference to a value available while invoking a {@link Call}: the child
+ * widget, the current list item, its index, the preceding sibling, or the
+ * adopted instance a container returned for the child.
+ */
+export type ArgRef = (typeof ARG_REFS)[number];
+
+/**
+ * A single argument passed to a method {@link Call}: an {@link ArgRef}, a value
+ * read from a React prop (`{ prop }`), a field read off the current item with an
+ * optional fallback (`{ field, or }`), or a constant (`{ literal }`).
+ */
+export type Arg = ArgRef | { prop: string } | { field: string; or?: JsonValue } | { literal: JsonValue };
+
+/**
+ * A GObject method invocation: either a bare method name called with default
+ * arguments, or a method name paired with an explicit list of {@link Arg}s.
+ */
+export type Call = string | { method: string; args: Arg[] };
+
+const NAME_MESSAGE = "must be a non-empty string";
+
+const JSON_MESSAGE = "must be a JSON-serializable value";
+
+const ARG_MESSAGE = "must be one of: reference name, { prop }, { field }, { literal }";
+
+const ARG_REF_SET: Set<string> = new Set(ARG_REFS);
+
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isJsonValue = (value: unknown): boolean => {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value)) return value.every(isJsonValue);
+    if (isRecord(value)) return Object.values(value).every(isJsonValue);
+    return false;
+};
+
+type IssuePath = Array<string | number>;
+
+type CollectedIssue = { path: IssuePath; message: string };
+
+export const rawIssue = (input: unknown, path: IssuePath, message: string, standalone = false) => ({
+    code: "custom" as const,
+    input,
+    path,
+    message,
+    continue: true as const,
+    ...(standalone ? { params: { standalone: true } } : {}),
+});
+
+const unknownKeyIssues = (value: Record<string, unknown>, allowed: string[]): CollectedIssue[] =>
+    Object.keys(value)
+        .filter((key) => !allowed.includes(key))
+        .map((key) => ({ path: [key], message: "is not a recognized key" }));
+
+const requireName = (value: unknown): boolean => typeof value === "string" && value.length > 0;
+
+const collectPropArgIssues = (value: Record<string, unknown>): CollectedIssue[] => {
+    const issues = unknownKeyIssues(value, ["prop"]);
+    if (!requireName(value.prop)) issues.push({ path: ["prop"], message: NAME_MESSAGE });
+    return issues;
+};
+
+const collectFieldArgIssues = (value: Record<string, unknown>): CollectedIssue[] => {
+    const issues = unknownKeyIssues(value, ["field", "or"]);
+    if (!requireName(value.field)) issues.push({ path: ["field"], message: NAME_MESSAGE });
+    if ("or" in value && !isJsonValue(value.or)) issues.push({ path: ["or"], message: JSON_MESSAGE });
+    return issues;
+};
+
+const collectLiteralArgIssues = (value: Record<string, unknown>): CollectedIssue[] => {
+    const issues = unknownKeyIssues(value, ["literal"]);
+    if (!isJsonValue(value.literal)) issues.push({ path: ["literal"], message: JSON_MESSAGE });
+    return issues;
+};
+
+const collectArgIssues = (value: unknown): CollectedIssue[] => {
+    if (typeof value === "string") {
+        return ARG_REF_SET.has(value) ? [] : [{ path: [], message: `has unknown reference "${value}"` }];
+    }
+    if (!isRecord(value)) return [{ path: [], message: ARG_MESSAGE }];
+    if ("prop" in value) return collectPropArgIssues(value);
+    if ("field" in value) return collectFieldArgIssues(value);
+    if ("literal" in value) return collectLiteralArgIssues(value);
+    return [{ path: [], message: ARG_MESSAGE }];
+};
+
+const collectArgsIssues = (args: unknown[]): CollectedIssue[] =>
+    args.flatMap((arg, index) =>
+        collectArgIssues(arg).map((issue) => ({ path: ["args", index, ...issue.path], message: issue.message })),
+    );
+
+const collectCallIssues = (value: unknown): CollectedIssue[] => {
+    if (typeof value === "string") return value.length === 0 ? [{ path: [], message: NAME_MESSAGE }] : [];
+    if (!isRecord(value)) return [{ path: [], message: "must be an object" }];
+    const issues = unknownKeyIssues(value, ["method", "args"]);
+    if (!requireName(value.method)) issues.push({ path: ["method"], message: NAME_MESSAGE });
+    if (!Array.isArray(value.args)) issues.push({ path: ["args"], message: "must be an array" });
+    else issues.push(...collectArgsIssues(value.args));
+    return issues;
+};
+
+const callSchema = z.custom<Call>().check((ctx) => {
+    ctx.issues.push(...collectCallIssues(ctx.value).map((issue) => rawIssue(ctx.value, issue.path, issue.message)));
+});
+
+const nameSchema = z.string({ error: NAME_MESSAGE }).min(1, { error: NAME_MESSAGE });
+
+const adoptSchema = z.union([z.literal(true), nameSchema], {
+    error: "must be `true` or the name of a getter method",
+});
+
+const containerSchema = z.strictObject({
+    kind: z.literal("container"),
+    prop: nameSchema,
+    child: nameSchema,
+    append: callSchema.optional(),
+    remove: callSchema.optional(),
+    insert: callSchema.optional(),
+    reorder: callSchema.optional(),
+    autowrap: nameSchema.optional(),
+    adopt: adoptSchema.optional(),
+});
+
+const valueSchema = z.strictObject({
+    kind: z.literal("value"),
+    prop: nameSchema,
+    call: callSchema,
+    after: nameSchema.optional(),
+});
+
+const controlledTextSchema = z.strictObject({
+    kind: z.literal("controlled-text"),
+    prop: nameSchema,
+});
+
+const lazySchema = z.strictObject({
+    kind: z.literal("lazy"),
+    prop: nameSchema,
+    lookup: nameSchema.optional(),
+});
+
+const listSchema = z.strictObject({
+    kind: z.literal("list"),
+    prop: nameSchema,
+    add: z.union([callSchema, z.array(callSchema).min(1)]),
+    remove: callSchema.optional(),
+    clear: callSchema.optional(),
+});
+
+const elementPropSchema = z
+    .discriminatedUnion("kind", [containerSchema, valueSchema, controlledTextSchema, lazySchema, listSchema], {
+        error: "must be one of container, value, controlled-text, lazy, list",
+    })
+    .check((ctx) => {
+        const prop = ctx.value;
+        if (prop.kind === "container" && prop.append === undefined && prop.remove === undefined) {
+            ctx.issues.push(rawIssue(prop, [], "must define at least one of `append` or `remove`"));
+        }
+    });
+
+export const elementPropsSchema = z.record(nameSchema, z.array(elementPropSchema));
+
+/**
+ * Rule describing how children of a given type are attached to and removed from a
+ * container element. `prop` is the React prop holding the children and `child` the
+ * child GObject type. `append`/`remove` add and remove a child, `insert` places
+ * one at an index or after a sibling, `reorder` moves an existing child, `autowrap`
+ * names a widget type each child is wrapped in before attaching, and `adopt` marks
+ * pre-existing children as adopted (`true`) or names the getter returning them.
+ */
+export type ContainerProp = z.infer<typeof containerSchema>;
+
+/**
+ * Rule that applies a scalar prop value by invoking `call` whenever the value
+ * changes, optionally running the method named by `after` once it is set.
+ */
+export type ValueProp = z.infer<typeof valueSchema>;
+
+/**
+ * Rule for a controlled text prop: `prop` is written directly to the GObject
+ * property and kept in sync with the element's own edits.
+ */
+export type ControlledTextProp = z.infer<typeof controlledTextSchema>;
+
+/**
+ * Rule for a prop applied after construction rather than at construction time,
+ * optionally guarded by `lookup`, a method that must succeed for the value before
+ * it is assigned.
+ */
+export type LazyProp = z.infer<typeof lazySchema>;
+
+/**
+ * Rule mapping an array prop to method calls: `add` runs per added item (a single
+ * call, or a sequence of calls applied in order when one item needs several), `remove`
+ * per removed item, and `clear` empties the collection before re-adding.
+ */
+export type ListProp = z.infer<typeof listSchema>;
+
+/**
+ * Any prop rule applied directly to an element instance rather than through
+ * container child attachment: a {@link ValueProp}, {@link ControlledTextProp},
+ * {@link LazyProp}, or {@link ListProp}.
+ */
+export type AppliedProp = ValueProp | ControlledTextProp | LazyProp | ListProp;
+
+/**
+ * A single entry in an element's prop mapping, discriminated by `kind`: a
+ * container, value, controlled-text, lazy, or list rule.
+ */
+export type ElementProp = z.infer<typeof elementPropSchema>;
+
+const CONFIG_PREFIX = "gtkx.config.ts:";
+
+const dottedPath = (segments: PropertyKey[]): string =>
+    segments.reduce<string>((acc, segment) => {
+        if (typeof segment === "number") return `${acc}[${segment}]`;
+        return acc === "" ? String(segment) : `${acc}.${String(segment)}`;
+    }, "");
+
+const isStandaloneIssue = (issue: z.core.$ZodIssue): boolean =>
+    "params" in issue && isRecord(issue.params) && issue.params.standalone === true;
+
+const formatIssue = (issue: z.core.$ZodIssue, fullPath: PropertyKey[]): string => {
+    if (issue.code === "unrecognized_keys") {
+        const [key] = issue.keys;
+        const path = dottedPath(key === undefined ? fullPath : [...fullPath, key]);
+        return `${CONFIG_PREFIX} \`${path}\` is not a recognized key`;
+    }
+    if (isStandaloneIssue(issue)) return `${CONFIG_PREFIX} ${issue.message}`;
+    const path = dottedPath(fullPath);
+    return path === "" ? `${CONFIG_PREFIX} ${issue.message}` : `${CONFIG_PREFIX} \`${path}\` ${issue.message}`;
+};
+
+export const configError = (error: z.ZodError): Error => {
+    const issue = error.issues[0];
+    if (issue === undefined) return new Error(`${CONFIG_PREFIX} invalid configuration`);
+    return new Error(formatIssue(issue, issue.path));
+};

package/src/index.ts

@@ -1,88 +1,20 @@
-export { gtkxBundledModulePatterns } from "./bundled-modules.js";
 export {
+    type Config,
     defineConfig,
-    GIR_NAMESPACE_PATTERN,
-    type GtkxConfig,
-    type GtkxConfigEnv,
-    type GtkxConfigExport,
-    type GtkxConfigFn,
-    type GtkxConfigFnPromise,
-    LIBRARIES_WILDCARD,
     mergeConfig,
-    type ReactCompilerCompilationMode,
-    type ReactCompilerOptions,
-    type ReactCompilerPanicThreshold,
-    type ResolvedGtkxConfig,
+    type ResolvedConfig,
     type ResolvedReactCompilerOptions,
-    resolveGtkxConfig,
-    resolveReactCompilerOptions,
-    validateGtkxConfig,
 } from "./config.js";
-export { DATA_IMPORT_KEY, DATA_IMPORT_PREFIX, resolveDataDir } from "./data-dir.js";
-export {
-    createGtkxConfigLoader,
-    type GtkxConfigLoader,
-    GtkxConfigNotFoundError,
-    type LoadedConfig,
-    type LoadGtkxConfigOptions,
-    type LoadResolvedGtkxConfigOptions,
-    loadGtkxConfig,
-    loadResolvedGtkxConfig,
-} from "./loader.js";
-export { createGtkxConfigPlugin, type GtkxConfigPluginOptions } from "./plugin.js";
-export type {
-    AddMethodArg,
-    AddMethodRule,
-    PageMetaSetter,
-    PropCondition,
-    PropRule,
-    SetterPropGroup,
-    SetterPropStep,
-    SignalPropRule,
-} from "./table-rules-ir.js";
 export type {
-    ArrayPropRow,
-    AttachShape,
-    AttachShapeTable,
-    AttachVerb,
-    CallArg,
-    CallStep,
-    ConstructSetter,
-    ConstructStep,
-    ContainerPropRow,
-    DetachGuard,
-    ElementMapRule,
-    MethodVerb,
-    ObjectPropRow,
-    OrderedInsertVerb,
-    PerElementPropRows,
-    PresenceCondition,
-    UserTableRows,
-    VerbArgs,
-    VirtualPropRow,
-} from "./table-schema.js";
-export {
-    CAMEL_CASE_NAME_PATTERN,
-    PASCAL_CASE_NAME_PATTERN,
-    validateArrayOf,
-} from "./validators.js";
-export {
-    GTKX_CONFIG_VIRTUAL_ID,
-    RESOLVED_GTKX_CONFIG_VIRTUAL_ID,
-    renderGtkxConfigModule,
-    type SerializedGtkxConfig,
-    serializeGtkxConfig,
-} from "./virtual.js";
-export {
-    BUFFER_TEXT_KIND,
-    CONTAINER_PROP_KIND,
-    LABEL_TEXT_KIND,
-    LAYOUT_CHILD_KIND,
-    META_OBJECT_KIND,
-    OVERLAY_KIND,
-    SLOT_KIND,
-    TAB_LABEL_KIND,
-    TEXT_ANCHOR_KIND,
-    TEXT_PAINTABLE_KIND,
-    WRAPPER_NODE_ELEMENT,
-} from "./wrapper-protocol.js";
+    AppliedProp,
+    Arg,
+    ArgRef,
+    Call,
+    ContainerProp,
+    ControlledTextProp,
+    ElementProp,
+    LazyProp,
+    ListProp,
+    ValueProp,
+} from "./element-props.js";
+export { type LoadedConfig, loadConfig } from "./loader.js";

package/src/internal.ts

@@ -0,0 +1,2 @@
+export { GIR_LIBRARY_PATTERN, isValidApplicationId, LIBRARIES_WILDCARD } from "./config.js";
+export { type ConfigLoader, createConfigLoader } from "./loader.js";

package/src/loader.ts

@@ -1,86 +1,66 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { loadConfig } from "c12";
-import { type GtkxConfig, type ResolvedGtkxConfig, resolveGtkxConfig, validateGtkxConfig } from "./config.js";
+import { loadConfig as loadConfigFile } from "c12";
+import { type Config, type ResolvedConfig, resolveConfig, validateConfig } from "./config.js";
 
+/**
+ * Result of loading a `gtkx.config.ts` file: the parsed configuration, the
+ * resolved config file path (`undefined` when none was found), and the project
+ * root it was loaded from.
+ */
 export type LoadedConfig = {
-    config: GtkxConfig;
+    config: Config;
     configFile: string | undefined;
-    rootDir: string;
+    root: string;
 };
 
-export class GtkxConfigNotFoundError extends Error {
-    constructor(cwd: string) {
-        super(
-            `No gtkx.config.ts found in ${cwd}.\n` +
-                `Create one with:\n` +
-                `\n` +
-                `  // gtkx.config.ts\n` +
-                `  import { defineConfig } from "@gtkx/config";\n` +
-                `\n` +
-                `  export default defineConfig({\n` +
-                `      libraries: ["Gtk-4.0", "Adw-1"],\n` +
-                `  });\n`,
-        );
-        this.name = "GtkxConfigNotFoundError";
-    }
-}
-
-export type LoadGtkxConfigOptions = {
-    mode?: string;
+export type LoadConfigOptions = {
+    mode?: string | undefined;
 };
 
-export const loadGtkxConfig = async (cwd: string, options: LoadGtkxConfigOptions = {}): Promise<LoadedConfig> => {
-    const result = await loadConfig<GtkxConfig>({
+/**
+ * Loads and validates the `gtkx.config.ts` file for a project, returning the
+ * parsed configuration together with the config file path and project root.
+ * @param cwd Directory from which to search for the configuration file.
+ * @param options Loading options, such as the environment mode.
+ */
+export const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise<LoadedConfig> => {
+    const result = await loadConfigFile<Config>({
         name: "gtkx",
         cwd,
         rcFile: false,
         globalRc: false,
         packageJson: false,
         context: { mode: options.mode },
+        ...(options.mode !== undefined ? { envName: options.mode } : {}),
     });
 
-    if (!result.configFile || !result.config || !existsSync(resolve(cwd, result.configFile))) {
-        throw new GtkxConfigNotFoundError(cwd);
-    }
+    const config = result.config;
+    const found = result.configFile !== undefined && existsSync(resolve(cwd, result.configFile));
 
-    validateGtkxConfig(result.config);
+    if (found) validateConfig(config);
 
     return {
-        config: result.config,
-        configFile: result.configFile,
-        rootDir: result.cwd ?? cwd,
+        config,
+        configFile: found ? result.configFile : undefined,
+        root: result.cwd ?? cwd,
     };
 };
 
-export type LoadResolvedGtkxConfigOptions = LoadGtkxConfigOptions & {
-    allowMissing?: boolean;
-};
+export type ConfigLoader = (cwd: string) => Promise<ResolvedConfig>;
 
-export const loadResolvedGtkxConfig = async (
-    cwd: string,
-    options: LoadResolvedGtkxConfigOptions = {},
-): Promise<ResolvedGtkxConfig> => {
-    try {
-        const { config } = await loadGtkxConfig(cwd, options.mode === undefined ? {} : { mode: options.mode });
-        return resolveGtkxConfig(config);
-    } catch (error) {
-        if (options.allowMissing && error instanceof GtkxConfigNotFoundError) {
-            return resolveGtkxConfig({});
-        }
-        throw error;
-    }
-};
-
-export type GtkxConfigLoader = (cwd: string) => Promise<ResolvedGtkxConfig>;
-
-export const createGtkxConfigLoader = (options: LoadResolvedGtkxConfigOptions = {}): GtkxConfigLoader => {
-    const cache = new Map<string, Promise<ResolvedGtkxConfig>>();
-    return (cwd: string): Promise<ResolvedGtkxConfig> => {
+export const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
+    const cache = new Map<string, Promise<ResolvedConfig>>();
+    const loadResolved = async (root: string): Promise<ResolvedConfig> => {
+        const { config } = await loadConfig(root, options);
+        validateConfig(config);
+        return resolveConfig(config);
+    };
+    return (cwd: string): Promise<ResolvedConfig> => {
         const root = resolve(cwd);
         let pending = cache.get(root);
         if (!pending) {
-            pending = loadResolvedGtkxConfig(root, options);
+            pending = loadResolved(root);
             cache.set(root, pending);
         }
         return pending;

package/src/virtual.ts

@@ -1,4 +1,4 @@
-import type { ResolvedGtkxConfig } from "./config.js";
+import type { ResolvedConfig } from "./config.js";
 
 export const GTKX_CONFIG_VIRTUAL_ID = "virtual:gtkx-config";
 
@@ -6,37 +6,8 @@ export const RESOLVED_GTKX_CONFIG_VIRTUAL_ID: string = `\0${GTKX_CONFIG_VIRTUAL_
 
 const METADATA_SPECIFIER = "@gtkx/jsx/metadata";
 
-export type SerializedGtkxConfig = Pick<
-    ResolvedGtkxConfig,
-    | "libraries"
-    | "girPath"
-    | "applicationId"
-    | "containerProps"
-    | "arrayProps"
-    | "objectProps"
-    | "virtualProps"
-    | "elementMap"
-    | "reactCompiler"
->;
-
-const serializeConfigValue = (value: unknown): string => (value === undefined ? "undefined" : JSON.stringify(value));
-
-export const serializeGtkxConfig = (config: ResolvedGtkxConfig): SerializedGtkxConfig => ({
-    libraries: config.libraries,
-    girPath: config.girPath,
-    applicationId: config.applicationId,
-    containerProps: config.containerProps,
-    arrayProps: config.arrayProps,
-    objectProps: config.objectProps,
-    virtualProps: config.virtualProps,
-    elementMap: config.elementMap,
-    reactCompiler: config.reactCompiler,
-});
-
-export const renderGtkxConfigModule = (config: ResolvedGtkxConfig): string =>
+export const renderConfigModule = (config: ResolvedConfig): string =>
     [
         `export * from ${JSON.stringify(METADATA_SPECIFIER)};`,
-        ...Object.entries(serializeGtkxConfig(config)).map(
-            ([key, value]) => `export const ${key} = ${serializeConfigValue(value)};`,
-        ),
+        `export const applicationId = ${JSON.stringify(config.applicationId)};`,
     ].join("\n");

package/src/vite-plugin.ts

@@ -0,0 +1,37 @@
+import type { Plugin, UserConfig } from "vite";
+import { type ConfigLoader, createConfigLoader } from "./loader.js";
+import { GTKX_CONFIG_VIRTUAL_ID, RESOLVED_GTKX_CONFIG_VIRTUAL_ID, renderConfigModule } from "./virtual.js";
+
+/**
+ * Creates the Vite plugin that resolves and serves the `virtual:gtkx-config`
+ * module, exposing the JSX metadata and the resolved application ID from the
+ * project's configuration.
+ * @param options Plugin name, an optional custom {@link ConfigLoader}, and an
+ * optional hook returning extra Vite user config.
+ */
+const createConfigPlugin = (options: {
+    name: string;
+    loadConfig?: ConfigLoader;
+    config?: () => Omit<UserConfig, "plugins">;
+}): Plugin => {
+    const loadConfig = options.loadConfig ?? createConfigLoader();
+    let root: string | undefined;
+
+    return {
+        name: options.name,
+        config(config: UserConfig) {
+            root = config.root ?? root;
+            return options.config?.();
+        },
+        resolveId(id: string) {
+            if (id === GTKX_CONFIG_VIRTUAL_ID) return RESOLVED_GTKX_CONFIG_VIRTUAL_ID;
+            return undefined;
+        },
+        async load(id: string) {
+            if (id !== RESOLVED_GTKX_CONFIG_VIRTUAL_ID) return undefined;
+            return renderConfigModule(await loadConfig(root ?? process.cwd()));
+        },
+    };
+};
+
+export default createConfigPlugin;

package/dist/bundled-modules.d.ts

@@ -1,2 +0,0 @@
-export declare const gtkxBundledModulePatterns: RegExp[];
-//# sourceMappingURL=bundled-modules.d.ts.map

package/dist/bundled-modules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundled-modules.d.ts","sourceRoot":"","sources":["../src/bundled-modules.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,EAAE,MAAM,EAAyE,CAAC"}

package/dist/bundled-modules.js

@@ -1,2 +0,0 @@
-export const gtkxBundledModulePatterns = [/@gtkx\/(config|ffi|gi|react|jsx|testing|css)/, /[/\\]\.gtkx[/\\]/];
-//# sourceMappingURL=bundled-modules.js.map

package/dist/bundled-modules.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundled-modules.js","sourceRoot":"","sources":["../src/bundled-modules.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yBAAyB,GAAa,CAAC,8CAA8C,EAAE,kBAAkB,CAAC,CAAC"}

package/dist/data-dir.d.ts

@@ -1,4 +0,0 @@
-export declare const DATA_IMPORT_PREFIX = "#data";
-export declare const DATA_IMPORT_KEY: string;
-export declare const resolveDataDir: (root: string) => string | null;
-//# sourceMappingURL=data-dir.d.ts.map

package/dist/data-dir.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-dir.d.ts","sourceRoot":"","sources":["../src/data-dir.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAE1C,eAAO,MAAM,eAAe,EAAE,MAAkC,CAAC;AAuBjE,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAAM,GAAG,IAUtD,CAAC"}

package/dist/data-dir.js

@@ -1,37 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-export const DATA_IMPORT_PREFIX = "#data";
-export const DATA_IMPORT_KEY = `${DATA_IMPORT_PREFIX}/*`;
-const CONDITION_PRIORITY = ["default", "import", "node"];
-const targetString = (entry) => {
-    if (typeof entry === "string")
-        return entry;
-    if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
-        const conditions = entry;
-        for (const condition of CONDITION_PRIORITY) {
-            const value = conditions[condition];
-            if (typeof value === "string")
-                return value;
-        }
-    }
-    return null;
-};
-const DATA_TARGET_PATTERN = /^\.?\/?(.+?)\/\*$/;
-const directoryFromTarget = (target) => {
-    const match = DATA_TARGET_PATTERN.exec(target);
-    return match?.[1] ?? null;
-};
-export const resolveDataDir = (root) => {
-    let manifest;
-    try {
-        manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
-    }
-    catch {
-        return null;
-    }
-    const target = targetString(manifest.imports?.[DATA_IMPORT_KEY]);
-    if (target === null)
-        return null;
-    return directoryFromTarget(target);
-};
-//# sourceMappingURL=data-dir.js.map

package/dist/data-dir.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-dir.js","sourceRoot":"","sources":["../src/data-dir.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAE1C,MAAM,CAAC,MAAM,eAAe,GAAW,GAAG,kBAAkB,IAAI,CAAC;AAEjE,MAAM,kBAAkB,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAU,CAAC;AAElE,MAAM,YAAY,GAAG,CAAC,KAAc,EAAiB,EAAE;IACnD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACvE,MAAM,UAAU,GAAG,KAAgC,CAAC;QACpD,KAAK,MAAM,SAAS,IAAI,kBAAkB,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;QAChD,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AAEhD,MAAM,mBAAmB,GAAG,CAAC,MAAc,EAAiB,EAAE;IAC1D,MAAM,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/C,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC9B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAY,EAAiB,EAAE;IAC1D,IAAI,QAA+C,CAAC;IACpD,IAAI,CAAC;QACD,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7E,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;IACjE,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC,CAAC"}

package/dist/plugin.d.ts

@@ -1,9 +0,0 @@
-import type { Plugin, UserConfig } from "vite";
-import { type GtkxConfigLoader } from "./loader.js";
-export interface GtkxConfigPluginOptions {
-    name: string;
-    loadConfig?: GtkxConfigLoader;
-    config?: (config: UserConfig) => Omit<UserConfig, "plugins"> | null | undefined;
-}
-export declare const createGtkxConfigPlugin: (options: GtkxConfigPluginOptions) => Plugin;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,EAA0B,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG5E,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;CACnF;AAED,eAAO,MAAM,sBAAsB,GAAI,SAAS,uBAAuB,KAAG,MAmBzE,CAAC"}

package/dist/plugin.js

@@ -1,24 +0,0 @@
-import { createGtkxConfigLoader } from "./loader.js";
-import { GTKX_CONFIG_VIRTUAL_ID, RESOLVED_GTKX_CONFIG_VIRTUAL_ID, renderGtkxConfigModule } from "./virtual.js";
-export const createGtkxConfigPlugin = (options) => {
-    const loadConfig = options.loadConfig ?? createGtkxConfigLoader();
-    let root;
-    return {
-        name: options.name,
-        config(config) {
-            root = config.root ?? root;
-            return options.config?.(config) ?? undefined;
-        },
-        resolveId(id) {
-            if (id === GTKX_CONFIG_VIRTUAL_ID)
-                return RESOLVED_GTKX_CONFIG_VIRTUAL_ID;
-            return undefined;
-        },
-        async load(id) {
-            if (id !== RESOLVED_GTKX_CONFIG_VIRTUAL_ID)
-                return undefined;
-            return renderGtkxConfigModule(await loadConfig(root ?? process.cwd()));
-        },
-    };
-};
-//# sourceMappingURL=plugin.js.map