@orgajs/orgx 1.0.7 → 2.0.0

package/LICENSE.org

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 gatsbyjs
+
+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/dist/index.d.ts

@@ -1,5 +1,11 @@
-export { createProcessor } from './processor';
-export { compile, compileSync } from './compile';
-export { evaluate, evaluateSync, RuntimeOptions } from './evaluate';
-export type { ProcessorOptions } from './processor';
-//# sourceMappingURL=index.d.ts.map
+export { createProcessor } from "./lib/core.js";
+export type ProcessorOptions = import('./lib/core.js').ProcessorOptions;
+export type CompileOptions = import('./lib/compile.js').CompileOptions;
+export type EvaluateOptions = import('./lib/evaluate.js').EvaluateOptions;
+export type OrgComponents = import('./lib/types.js').OrgComponents;
+export type OrgContent = import('./lib/types.js').OrgContent;
+export type OrgModule = import('./lib/types.js').OrgModule;
+export type OrgProps = import('./lib/types.js').OrgProps;
+export { compile, compileSync } from "./lib/compile.js";
+export { evaluate, evaluateSync } from "./lib/evaluate.js";
+export { run, runSync } from "./lib/run.js";

package/dist/lib/compile.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Compile MDX to JS.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {CompileOptions | null | undefined} [compileOptions]
+ *   Compile configuration.
+ * @return {Promise<VFile>}
+ *   File.
+ */
+export function compile(vfileCompatible: VFileCompatible, compileOptions?: CompileOptions | null | undefined): Promise<VFile>;
+/**
+ * Synchronously compile MDX to JS.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {CompileOptions | null | undefined} [compileOptions]
+ *   Compile configuration.
+ * @return {VFile}
+ *   File.
+ */
+export function compileSync(vfileCompatible: VFileCompatible, compileOptions?: CompileOptions | null | undefined): VFile;
+export type VFile = import('vfile').VFile;
+export type VFileCompatible = import('vfile').VFileCompatible;
+export type PluginOptions = import('./core.js').PluginOptions;
+export type BaseProcessorOptions = import('./core.js').BaseProcessorOptions;
+/**
+ * Core configuration.
+ */
+export type CoreProcessorOptions = Omit<BaseProcessorOptions, 'format'>;
+/**
+ * Extra configuration.
+ */
+export type ExtraOptions = {
+    /**
+     * Format of `file`.
+     */
+    format?: 'detect' | 'mdx' | 'md' | null | undefined;
+};
+/**
+ * Configuration.
+ */
+export type CompileOptions = CoreProcessorOptions & PluginOptions & ExtraOptions;

package/dist/lib/condition.browser.d.ts

@@ -0,0 +1 @@
+export const development: false;

package/dist/lib/condition.d.ts

@@ -0,0 +1 @@
+export const development: boolean;

package/dist/lib/core.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Pipeline to:
+ *
+ * 1. Parse org-mode
+ * 2. Transform through reorg (oast), rehype (hast), and recma (esast)
+ * 3. Serialize as JavaScript
+ *
+ * @param {ProcessorOptions | null | undefined} [options]
+ *   Configuration.
+ * @return {Processor}
+ *   Processor.
+ */
+export function createProcessor(options?: ProcessorOptions | null | undefined): Processor;
+export type PluggableList = import('unified').PluggableList;
+export type Processor = import('unified').Processor;
+export type RehypeRecmaOptions = import('./plugin/rehype-recma.js').Options;
+export type RecmaDocumentOptions = import('./plugin/recma-document.js').RecmaDocumentOptions;
+export type RecmaStringifyOptions = import('./plugin/recma-stringify.js').RecmaStringifyOptions;
+export type RecmaJsxRewriteOptions = import('./plugin/recma-jsx-rewrite.js').RecmaJsxRewriteOptions;
+/**
+ * Base configuration.
+ */
+export type BaseProcessorOptions = {
+    /**
+     * Whether to keep JSX.
+     * Format of the files to be processed.
+     */
+    jsx?: boolean | null | undefined;
+    /**
+     * Whether to compile to a whole program or a function body..
+     */
+    outputFormat?: 'function-body' | 'program';
+    /**
+     * List of recma (esast, JavaScript) plugins.
+     */
+    recmaPlugins?: import("unified").PluggableList | null | undefined;
+    /**
+     * List of remark (mdast, markdown) plugins.
+     */
+    reorgPlugins?: import("unified").PluggableList | null | undefined;
+    /**
+     * List of rehype (hast, HTML) plugins.
+     */
+    rehypePlugins?: import("unified").PluggableList | null | undefined;
+    /**
+     * Options to pass through to `reorg-rehype`.
+     */
+    reorgRehypeOptions?: import('@orgajs/reorg-rehype').Options | null | undefined;
+};
+/**
+ * Configuration for internal plugins.
+ */
+export type PluginOptions = Omit<RehypeRecmaOptions & RecmaDocumentOptions & RecmaStringifyOptions & RecmaJsxRewriteOptions, 'outputFormat'>;
+/**
+ * Configuration for processor.
+ */
+export type ProcessorOptions = BaseProcessorOptions & PluginOptions;

package/dist/lib/evaluate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Evaluate MDX.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {EvaluateOptions} evaluateOptions
+ *   Configuration for evaluation.
+ * @return {Promise<ExportMap>}
+ *   Export map.
+ */
+export function evaluate(vfileCompatible: VFileCompatible, evaluateOptions: EvaluateOptions): Promise<ExportMap>;
+/**
+ * Synchronously evaluate MDX.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {EvaluateOptions} evaluateOptions
+ *   Configuration for evaluation.
+ * @return {ExportMap}
+ *   Export map.
+ */
+export function evaluateSync(vfileCompatible: VFileCompatible, evaluateOptions: EvaluateOptions): ExportMap;
+export type ExportMap = import('./types.js').OrgModule;
+export type VFileCompatible = import('vfile').VFileCompatible;
+export type EvaluateOptions = import('./util/resolve-evaluate-options.js').EvaluateOptions;

package/dist/lib/plugin/recma-document.d.ts

@@ -0,0 +1,63 @@
+export function recmaDocument(this: import("unified").Processor<void, import("estree").Program, void, void>, ...settings: [] | [RecmaDocumentOptions | null | undefined]): void | import("unified").Transformer<import("estree").Program, import("estree").Program>;
+export type Directive = import('estree-jsx').Directive;
+export type ExportAllDeclaration = import('estree-jsx').ExportAllDeclaration;
+export type ExportDefaultDeclaration = import('estree-jsx').ExportDefaultDeclaration;
+export type ExportNamedDeclaration = import('estree-jsx').ExportNamedDeclaration;
+export type ExportSpecifier = import('estree-jsx').ExportSpecifier;
+export type Expression = import('estree-jsx').Expression;
+export type FunctionDeclaration = import('estree-jsx').FunctionDeclaration;
+export type ImportDeclaration = import('estree-jsx').ImportDeclaration;
+export type ImportDefaultSpecifier = import('estree-jsx').ImportDefaultSpecifier;
+export type ImportExpression = import('estree-jsx').ImportExpression;
+export type ImportSpecifier = import('estree-jsx').ImportSpecifier;
+export type Literal = import('estree-jsx').Literal;
+export type JSXElement = import('estree-jsx').JSXElement;
+export type ModuleDeclaration = import('estree-jsx').ModuleDeclaration;
+export type Node = import('estree-jsx').Node;
+export type Program = import('estree-jsx').Program;
+export type Property = import('estree-jsx').Property;
+export type SimpleLiteral = import('estree-jsx').SimpleLiteral;
+export type SpreadElement = import('estree-jsx').SpreadElement;
+export type Statement = import('estree-jsx').Statement;
+export type VariableDeclarator = import('estree-jsx').VariableDeclarator;
+/**
+ * Configuration for internal plugin `recma-document`.
+ */
+export type RecmaDocumentOptions = {
+    /**
+     * Whether to use either `import` and `export` statements to get the runtime
+     * (and optionally provider) and export the content, or get values from
+     * `arguments` and return things.
+     */
+    outputFormat?: 'function-body' | 'program' | null | undefined;
+    /**
+     * Whether to keep `import` (and `export … from`) statements or compile them
+     * to dynamic `import()` instead.
+     */
+    useDynamicImport?: boolean | null | undefined;
+    /**
+     * Resolve `import`s (and `export … from`, and `import.meta.url`) relative to
+     * this URL.
+     */
+    baseUrl?: string | null | undefined;
+    /**
+     * Pragma for JSX (used in classic runtime).
+     */
+    pragma?: string | null | undefined;
+    /**
+     * Pragma for JSX fragments (used in classic runtime).
+     */
+    pragmaFrag?: string | null | undefined;
+    /**
+     * Where to import the identifier of `pragma` from (used in classic runtime).
+     */
+    pragmaImportSource?: string | null | undefined;
+    /**
+     * Place to import automatic JSX runtimes from (used in automatic runtime).
+     */
+    jsxImportSource?: string | null | undefined;
+    /**
+     * JSX runtime to use.
+     */
+    jsxRuntime?: 'automatic' | 'classic' | null | undefined;
+};

package/dist/lib/plugin/recma-jsx-build.d.ts

@@ -0,0 +1,14 @@
+export function recmaJsxBuild(this: import("unified").Processor<void, import("estree").Program, void, void>, ...settings: [RecmaJsxBuildOptions | null | undefined] | []): void | import("unified").Transformer<import("estree").Program, import("estree").Program>;
+export type Program = import('estree-jsx').Program;
+export type BuildJsxOptions = import('estree-util-build-jsx').BuildJsxOptions;
+/**
+ * Configuration for internal plugin `recma-jsx-build`.
+ */
+export type ExtraOptions = {
+    /**
+     * Whether to keep the import of the automatic runtime or get it from
+     * `arguments[0]` instead.
+     */
+    outputFormat?: 'function-body' | 'program' | null | undefined;
+};
+export type RecmaJsxBuildOptions = BuildJsxOptions & ExtraOptions;

package/dist/lib/plugin/recma-jsx-rewrite.d.ts

@@ -0,0 +1,50 @@
+export function recmaJsxRewrite(this: import("unified").Processor<void, import("estree").Program, void, void>, ...settings: [] | [RecmaJsxRewriteOptions | null | undefined]): void | import("unified").Transformer<import("estree").Program, import("estree").Program>;
+export type Expression = import('estree-jsx').Expression;
+export type EstreeFunction = import('estree-jsx').Function;
+export type Identifier = import('estree-jsx').Identifier;
+export type ImportSpecifier = import('estree-jsx').ImportSpecifier;
+export type JSXElement = import('estree-jsx').JSXElement;
+export type ModuleDeclaration = import('estree-jsx').ModuleDeclaration;
+export type Node = import('estree-jsx').Node;
+export type ObjectPattern = import('estree-jsx').ObjectPattern;
+export type Program = import('estree-jsx').Program;
+export type Property = import('estree-jsx').Property;
+export type Statement = import('estree-jsx').Statement;
+export type VariableDeclarator = import('estree-jsx').VariableDeclarator;
+export type Scope = import('periscopic').Scope & {
+    node: Node;
+};
+/**
+ * Configuration for internal plugin `recma-jsx-rewrite`.
+ */
+export type RecmaJsxRewriteOptions = {
+    /**
+     * Whether to use an import statement or `arguments[0]` to get the provider.
+     */
+    outputFormat?: 'function-body' | 'program' | null | undefined;
+    /**
+     * Place to import a provider from.
+     */
+    providerImportSource?: string | null | undefined;
+    /**
+     * Whether to add extra info to error messages in generated code.
+     *
+     * This also results in the development automatic JSX runtime
+     * (`/jsx-dev-runtime`, `jsxDEV`) being used, which passes positional info to
+     * nodes.
+     * The default can be set to `true` in Node.js through environment variables:
+     * set `NODE_ENV=development`.
+     */
+    development?: boolean | null | undefined;
+};
+export type StackEntry = {
+    objects: Array<string>;
+    components: Array<string>;
+    tags: Array<string>;
+    references: Record<string, {
+        node: JSXElement;
+        component: boolean;
+    }>;
+    idToInvalidComponentName: Map<string | number, string>;
+    node: EstreeFunction;
+};

package/dist/lib/plugin/recma-stringify.d.ts

@@ -0,0 +1,13 @@
+export function recmaStringify(this: import("unified").Processor<void, import("estree").Program, import("estree").Program, string>, ...settings: [] | [RecmaStringifyOptions | null | undefined]): void;
+export type Program = import('estree-jsx').Program;
+export type SourceMapGenerator = typeof import('source-map').SourceMapGenerator;
+/**
+ * Configuration for internal plugin `recma-stringify`.
+ */
+export type RecmaStringifyOptions = {
+    /**
+     * Generate a source map by passing a `SourceMapGenerator` from `source-map`
+     * in.
+     */
+    SourceMapGenerator?: SourceMapGenerator | null | undefined;
+};

package/dist/lib/plugin/rehype-recma.d.ts

@@ -0,0 +1,49 @@
+export function rehypeRecma(this: import("unified").Processor<void, import("hast").Root, void, void>, ...settings: [] | [Options | undefined]): void | import("unified").Transformer<import("hast").Root, import("estree").Program>;
+export type Program = import('estree-jsx').Program;
+export type Expression = import('estree-jsx').Expression;
+export type ModuleDeclaration = import('estree-jsx').ModuleDeclaration;
+export type Root = import('hast').Root;
+export type Handle = import('hast-util-to-estree').Handle;
+export type HastToEstreeOptions = import('hast-util-to-estree').Options;
+/**
+ * Specify casing to use for attribute names.
+ *
+ * HTML casing is for example `class`, `stroke-linecap`, `xml:lang`.
+ * React casing is for example `className`, `strokeLinecap`, `xmlLang`.
+ */
+export type ElementAttributeNameCase = 'html' | 'react';
+/**
+ * Casing to use for property names in `style` objects.
+ *
+ * CSS casing is for example `background-color` and `-webkit-line-clamp`.
+ * DOM casing is for example `backgroundColor` and `WebkitLineClamp`.
+ */
+export type StylePropertyNameCase = 'css' | 'dom';
+/**
+ * Configuration for internal plugin `rehype-recma`.
+ */
+export type MoreOptions = {
+    /**
+     * Specify casing to use for attribute names.
+     *
+     * This casing is used for hast elements, not for embedded Org JSX nodes
+     * (components that someone authored manually).
+     */
+    elementAttributeNameCase?: ElementAttributeNameCase | undefined | null;
+    /**
+     * Specify casing to use for property names in `style` objects.
+     *
+     * This casing is used for hast elements, not for embedded Org JSX nodes
+     * (components that someone authored manually).
+     */
+    stylePropertyNameCase?: StylePropertyNameCase | undefined | null;
+    /**
+     * - Whether to skip imports
+     */
+    skipImport?: boolean;
+    /**
+     * - Specify which hast properties to parse as JSX.
+     */
+    parseJSX?: string[];
+};
+export type Options = HastToEstreeOptions & MoreOptions;

package/dist/lib/run.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Asynchronously run code.
+ *
+ * @param {{toString(): string}} file
+ *   JS document to run.
+ * @param {unknown} options
+ *   Parameter.
+ * @return {Promise<any>}
+ *   Anything.
+ */
+export function run(file: {
+    toString(): string;
+}, options: unknown): Promise<any>;
+/**
+ * Synchronously run code.
+ *
+ * @param {{toString(): string}} file
+ *   JS document to run.
+ * @param {unknown} options
+ *   Parameter.
+ * @return {any}
+ *   Anything.
+ */
+export function runSync(file: {
+    toString(): string;
+}, options: unknown): any;

package/dist/lib/util/estree-util-create.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @typedef {import('estree-jsx').Node} Node
+ */
+/**
+ * @param {Node} from
+ *   Node to take from.
+ * @param {Node} to
+ *   Node to add to.
+ * @returns {void}
+ *   Nothing.
+ */
+export function create(from: Node, to: Node): void;
+export type Node = import('estree-jsx').Node;

package/dist/lib/util/estree-util-declaration-to-expression.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @typedef {import('estree-jsx').Declaration} Declaration
+ * @typedef {import('estree-jsx').Expression} Expression
+ */
+/**
+ * Turn a declaration into an expression.
+ *
+ * Doesn’t work for variable declarations, but that’s fine for our use case
+ * because currently we’re using this utility for export default declarations,
+ * which can’t contain variable declarations.
+ *
+ * @param {Declaration} declaration
+ *   Declaration.
+ * @returns {Expression}
+ *   Expression.
+ */
+export function declarationToExpression(declaration: Declaration): Expression;
+export type Declaration = import('estree-jsx').Declaration;
+export type Expression = import('estree-jsx').Expression;

package/dist/lib/util/estree-util-is-declaration.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @typedef {import('estree-jsx').Node} Node
+ * @typedef {import('estree-jsx').Declaration} Declaration
+ */
+/**
+ * Check if `node` is a declaration.
+ *
+ * @param {Node} node
+ *   Node to check.
+ * @returns {node is Declaration}
+ *   Whether `node` is a declaration.
+ */
+export function isDeclaration(node: Node): node is import("estree").Declaration;
+export type Node = import('estree-jsx').Node;
+export type Declaration = import('estree-jsx').Declaration;

package/dist/lib/util/estree-util-specifiers-to-declarations.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier>} specifiers
+ * @param {Expression} init
+ * @returns {Array<VariableDeclarator>}
+ */
+export function specifiersToDeclarations(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier>, init: Expression): Array<VariableDeclarator>;
+export type AssignmentProperty = import('estree-jsx').AssignmentProperty;
+export type ExportSpecifier = import('estree-jsx').ExportSpecifier;
+export type Expression = import('estree-jsx').Expression;
+export type Identifier = import('estree-jsx').Identifier;
+export type ImportDefaultSpecifier = import('estree-jsx').ImportDefaultSpecifier;
+export type ImportNamespaceSpecifier = import('estree-jsx').ImportNamespaceSpecifier;
+export type ImportSpecifier = import('estree-jsx').ImportSpecifier;
+export type VariableDeclarator = import('estree-jsx').VariableDeclarator;

package/dist/lib/util/estree-util-to-binary-addition.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @typedef {import('estree-jsx').Expression} Expression
+ */
+/**
+ * @param {Array<Expression>} expressions
+ */
+export function toBinaryAddition(expressions: Array<Expression>): import("estree").Expression;
+export type Expression = import('estree-jsx').Expression;

package/dist/lib/util/estree-util-to-id-or-member-expression.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {Array<string | number>} ids
+ * @returns {Identifier | MemberExpression}
+ */
+export function toIdOrMemberExpression(ids: Array<string | number>): Identifier | MemberExpression;
+export function toJsxIdOrMemberExpression(ids: Array<string | number>): JSXIdentifier | JSXMemberExpression;
+export type Identifier = import('estree-jsx').Identifier;
+export type JSXIdentifier = import('estree-jsx').JSXIdentifier;
+export type JSXMemberExpression = import('estree-jsx').JSXMemberExpression;
+export type Literal = import('estree-jsx').Literal;
+export type MemberExpression = import('estree-jsx').MemberExpression;

package/dist/lib/util/render-error.d.ts

@@ -0,0 +1,2 @@
+declare function _default(error: SyntaxError, bg?: string, color?: string): import('estree-jsx').Program;
+export default _default;

package/dist/lib/util/resolve-evaluate-options.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @typedef {import('../core.js').ProcessorOptions} ProcessorOptions
+ *
+ * @typedef RunnerOptions
+ *   Configuration with JSX runtime.
+ * @property {any} Fragment
+ *   Symbol to use for fragments.
+ * @property {any} [jsx]
+ *   Function to generate an element with static children in production mode.
+ * @property {any} [jsxs]
+ *   Function to generate an element with dynamic children in production mode.
+ * @property {any} [jsxDEV]
+ *   Function to generate an element in development mode.
+ * @property {any} [useOrgComponents]
+ *   Function to get `MDXComponents` from context.
+ *
+ * @typedef {Omit<ProcessorOptions, 'jsx' | 'jsxImportSource' | 'jsxRuntime' | 'pragma' | 'pragmaFrag' | 'pragmaImportSource' | 'providerImportSource' | 'outputFormat'> } EvaluateProcessorOptions
+ *   Compile configuration without JSX options for evaluation.
+ *
+ * @typedef {EvaluateProcessorOptions & RunnerOptions} EvaluateOptions
+ *   Configuration for evaluation.
+ */
+/**
+ * Split compiletime options from runtime options.
+ *
+ * @param {EvaluateOptions | null | undefined} options
+ * @returns {{compiletime: ProcessorOptions, runtime: RunnerOptions}}
+ */
+export function resolveEvaluateOptions(options: EvaluateOptions | null | undefined): {
+    compiletime: ProcessorOptions;
+    runtime: RunnerOptions;
+};
+export type ProcessorOptions = import('../core.js').ProcessorOptions;
+/**
+ * Configuration with JSX runtime.
+ */
+export type RunnerOptions = {
+    /**
+     *  Symbol to use for fragments.
+     */
+    Fragment: any;
+    /**
+     * Function to generate an element with static children in production mode.
+     */
+    jsx?: any;
+    /**
+     * Function to generate an element with dynamic children in production mode.
+     */
+    jsxs?: any;
+    /**
+     * Function to generate an element in development mode.
+     */
+    jsxDEV?: any;
+    /**
+     * Function to get `MDXComponents` from context.
+     */
+    useOrgComponents?: any;
+};
+/**
+ * Compile configuration without JSX options for evaluation.
+ */
+export type EvaluateProcessorOptions = Omit<ProcessorOptions, 'jsx' | 'jsxImportSource' | 'jsxRuntime' | 'pragma' | 'pragmaFrag' | 'pragmaImportSource' | 'providerImportSource' | 'outputFormat'>;
+/**
+ * Configuration for evaluation.
+ */
+export type EvaluateOptions = EvaluateProcessorOptions & RunnerOptions;

package/dist/lib/util/resolve-file-and-options.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a file and options from a given `vfileCompatible` and options that
+ * might contain `format: 'detect'`.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ * @param {CompileOptions | null | undefined} [options]
+ * @returns {{file: VFile, options: ProcessorOptions}}
+ */
+export function resolveFileAndOptions(vfileCompatible: VFileCompatible, options?: CompileOptions | null | undefined): {
+    file: VFile;
+    options: ProcessorOptions;
+};
+export type VFileCompatible = import('vfile').VFileCompatible;
+export type ProcessorOptions = import('../core.js').ProcessorOptions;
+export type CompileOptions = import('../compile.js').CompileOptions;
+import { VFile } from 'vfile';

package/index.js

@@ -0,0 +1,14 @@
+/**
+ * @typedef {import('./lib/core.js').ProcessorOptions} ProcessorOptions
+ * @typedef {import('./lib/compile.js').CompileOptions} CompileOptions
+ * @typedef {import('./lib/evaluate.js').EvaluateOptions} EvaluateOptions
+ * @typedef {import('./lib/types.js').OrgComponents} OrgComponents
+ * @typedef {import('./lib/types.js').OrgContent} OrgContent
+ * @typedef {import('./lib/types.js').OrgModule} OrgModule
+ * @typedef {import('./lib/types.js').OrgProps} OrgProps
+ */
+
+export { createProcessor } from './lib/core.js'
+export { compile, compileSync } from './lib/compile.js'
+export { evaluate, evaluateSync } from './lib/evaluate.js'
+export { run, runSync } from './lib/run.js'

package/lib/compile.js

@@ -0,0 +1,54 @@
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile').VFileCompatible} VFileCompatible
+ * @typedef {import('./core.js').PluginOptions} PluginOptions
+ * @typedef {import('./core.js').BaseProcessorOptions} BaseProcessorOptions
+ */
+
+/**
+ * @typedef {Omit<BaseProcessorOptions, 'format'>} CoreProcessorOptions
+ *   Core configuration.
+ *
+ * @typedef ExtraOptions
+ *   Extra configuration.
+ * @property {'detect' | 'mdx' | 'md' | null | undefined} [format='detect']
+ *   Format of `file`.
+ *
+ * @typedef {CoreProcessorOptions & PluginOptions & ExtraOptions} CompileOptions
+ *   Configuration.
+ */
+
+import {createProcessor} from './core.js'
+import {resolveFileAndOptions} from './util/resolve-file-and-options.js'
+
+/**
+ * Compile MDX to JS.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {CompileOptions | null | undefined} [compileOptions]
+ *   Compile configuration.
+ * @return {Promise<VFile>}
+ *   File.
+ */
+export function compile(vfileCompatible, compileOptions) {
+  const {file, options} = resolveFileAndOptions(vfileCompatible, compileOptions)
+  return createProcessor(options).process(file)
+}
+
+/**
+ * Synchronously compile MDX to JS.
+ *
+ * @param {VFileCompatible} vfileCompatible
+ *   MDX document to parse (`string`, `Buffer`, `vfile`, anything that can be
+ *   given to `vfile`).
+ * @param {CompileOptions | null | undefined} [compileOptions]
+ *   Compile configuration.
+ * @return {VFile}
+ *   File.
+ */
+export function compileSync(vfileCompatible, compileOptions) {
+  const {file, options} = resolveFileAndOptions(vfileCompatible, compileOptions)
+  return createProcessor(options).processSync(file)
+}

package/lib/condition.browser.js

@@ -0,0 +1 @@
+export const development = false

package/lib/condition.js

@@ -0,0 +1,3 @@
+import process from 'process'
+
+export const development = process.env.NODE_ENV === 'development'