@ydant/context 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 cwd-k2
+
+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,97 @@
+# @ydant/context
+
+Context API for Ydant.
+
+## Installation
+
+```bash
+pnpm add @ydant/context
+```
+
+## Usage
+
+### Context API
+
+```typescript
+import { mount, type Component } from "@ydant/core";
+import { createBasePlugin, div, text } from "@ydant/base";
+import { createContext, provide, inject, createContextPlugin } from "@ydant/context";
+
+// Create context with optional default value
+const ThemeContext = createContext<"light" | "dark">("light");
+
+// Parent component provides value
+const App: Component = () =>
+  div(function* () {
+    yield* provide(ThemeContext, "dark");
+    yield* ChildComponent();
+  });
+
+// Child component injects value
+const ChildComponent: Component = () =>
+  div(function* () {
+    const theme = yield* inject(ThemeContext);
+    yield* text(`Theme: ${theme}`); // "dark"
+  });
+
+// Mount with base and context plugins
+mount(App, document.getElementById("app")!, {
+  plugins: [createBasePlugin(), createContextPlugin()],
+});
+```
+
+> **Note:** `@ydant/base` is required for DOM rendering.
+
+## API
+
+### createContext
+
+```typescript
+function createContext<T>(defaultValue?: T): Context<T>;
+```
+
+Creates a context object that can be provided and injected.
+
+### provide
+
+```typescript
+function provide<T>(context: Context<T>, value: T): ContextProvide;
+```
+
+Provides a value to all descendant components. Use with `yield*`.
+
+### inject
+
+```typescript
+function inject<T>(context: Context<T>): ContextInject;
+```
+
+Retrieves the value from the nearest ancestor provider. Use with `yield*`. Returns the default value if no provider is found.
+
+### createContextPlugin
+
+```typescript
+function createContextPlugin(): Plugin;
+```
+
+Creates a plugin that handles `provide` and `inject`. Must be passed to `mount()`.
+
+The context plugin extends `RenderContext` and `PluginAPI`:
+
+```typescript
+// RenderContext extensions
+interface RenderContextExtensions {
+  contextValues: Map<symbol, unknown>;
+}
+
+// PluginAPI extensions
+interface PluginAPIExtensions {
+  getContext<T>(id: symbol): T | undefined;
+  setContext<T>(id: symbol, value: T): void;
+}
+```
+
+## Module Structure
+
+- `context.ts` - Context creation and provide/inject
+- `plugin.ts` - Plugin implementation

package/dist/context.d.ts

@@ -0,0 +1,62 @@
+import { Tagged, Primitive } from '@ydant/core';
+/** Context オブジェクト */
+export interface Context<T> {
+    /** Context の一意な識別子 */
+    readonly id: symbol;
+    /** デフォルト値 */
+    readonly defaultValue: T | undefined;
+}
+/** Context Provider 型（Tagged Union） */
+export type ContextProvide = Tagged<"context-provide", {
+    context: Context<unknown>;
+    value: unknown;
+}>;
+/** Context Inject 型（Tagged Union） */
+export type ContextInject = Tagged<"context-inject", {
+    context: Context<unknown>;
+}>;
+/** Context から値を取得する DSL プリミティブの戻り値型 */
+type Accessor<T> = Generator<ContextInject, T, T>;
+/**
+ * Context を作成する
+ *
+ * @param defaultValue - inject 時に provider が見つからない場合に使用される値
+ *
+ * @example
+ * ```typescript
+ * const ThemeContext = createContext<"light" | "dark">("light");
+ * const UserContext = createContext<User | null>(null);
+ * ```
+ */
+export declare function createContext<T>(defaultValue?: T): Context<T>;
+/**
+ * Context に値を提供する
+ *
+ * このジェネレーターを yield* すると、その子孫コンポーネントで
+ * inject() を使ってこの値を取得できるようになる。
+ *
+ * @param context - 提供する Context
+ * @param value - 提供する値
+ *
+ * @example
+ * ```typescript
+ * yield* provide(ThemeContext, "dark");
+ * ```
+ */
+export declare function provide<T>(context: Context<T>, value: T): Primitive<ContextProvide>;
+/**
+ * Context から値を取得する
+ *
+ * 親コンポーネントで provide された値を取得する。
+ * provider が見つからない場合は defaultValue を返す。
+ *
+ * @param context - 取得する Context
+ * @returns Context の値
+ *
+ * @example
+ * ```typescript
+ * const theme = yield* inject(ThemeContext);
+ * ```
+ */
+export declare function inject<T>(context: Context<T>): Accessor<T>;
+export {};

package/dist/global.d.ts

@@ -0,0 +1,32 @@
+import { ContextProvide, ContextInject } from './context';
+declare module "@ydant/core" {
+  // RenderContext に context プラグイン用のプロパティを追加
+  interface RenderContextExtensions {
+    /** Context の値を保持するマップ */
+    contextValues: Map<symbol, unknown>;
+  }
+
+  // PluginAPI に context プラグインのメソッドを追加
+  interface PluginAPIExtensions {
+    /** Context から値を取得 */
+    getContext<T>(id: symbol): T | undefined;
+    /** Context に値を設定 */
+    setContext<T>(id: symbol, value: T): void;
+  }
+
+  // context の DSL 型を Child に追加
+  interface PluginChildExtensions {
+    ContextProvide: ContextProvide;
+    ContextInject: ContextInject;
+  }
+
+  // inject の戻り値を ChildNext に追加
+  interface PluginNextExtensions {
+    ContextValue: unknown;
+  }
+
+  // inject の戻り値を ChildReturn に追加
+  interface PluginReturnExtensions {
+    ContextValue: unknown;
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="./global.d.ts" />
+export type { Context, ContextProvide, ContextInject } from './context';
+export { createContext, provide, inject } from './context';
+export { createContextPlugin } from './plugin';

package/dist/index.es.js

@@ -0,0 +1,46 @@
+import { isTagged as c } from "@ydant/core";
+function x(t) {
+  return {
+    id: Symbol("context"),
+    defaultValue: t
+  };
+}
+function* a(t, e) {
+  yield {
+    type: "context-provide",
+    context: t,
+    value: e
+  };
+}
+function* i(t) {
+  return yield {
+    type: "context-inject",
+    context: t
+  };
+}
+function s() {
+  return {
+    name: "context",
+    types: ["context-provide", "context-inject"],
+    dependencies: ["base"],
+    initContext(t, e) {
+      const n = e?.contextValues;
+      t.contextValues = n ? new Map(n) : /* @__PURE__ */ new Map();
+    },
+    extendAPI(t, e) {
+      const n = e.contextValues;
+      t.getContext = (o) => n.get(o), t.setContext = (o, r) => {
+        n.set(o, r);
+      };
+    },
+    process(t, e) {
+      return c(t, "context-provide") ? (e.setContext(t.context.id, t.value), {}) : c(t, "context-inject") ? { value: e.getContext(t.context.id) ?? t.context.defaultValue } : {};
+    }
+  };
+}
+export {
+  x as createContext,
+  s as createContextPlugin,
+  i as inject,
+  a as provide
+};

package/dist/index.umd.js

@@ -0,0 +1 @@
+(function(t,o){typeof exports=="object"&&typeof module<"u"?o(exports,require("@ydant/core")):typeof define=="function"&&define.amd?define(["exports","@ydant/core"],o):(t=typeof globalThis<"u"?globalThis:t||self,o(t.YdantContext={},t.YdantCore))})(this,(function(t,o){"use strict";function c(e){return{id:Symbol("context"),defaultValue:e}}function*r(e,n){yield{type:"context-provide",context:e,value:n}}function*d(e){return yield{type:"context-inject",context:e}}function a(){return{name:"context",types:["context-provide","context-inject"],dependencies:["base"],initContext(e,n){const i=n?.contextValues;e.contextValues=i?new Map(i):new Map},extendAPI(e,n){const i=n.contextValues;e.getContext=u=>i.get(u),e.setContext=(u,x)=>{i.set(u,x)}},process(e,n){return o.isTagged(e,"context-provide")?(n.setContext(e.context.id,e.value),{}):o.isTagged(e,"context-inject")?{value:n.getContext(e.context.id)??e.context.defaultValue}:{}}}}t.createContext=c,t.createContextPlugin=a,t.inject=d,t.provide=r,Object.defineProperty(t,Symbol.toStringTag,{value:"Module"})}));

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@ydant/core';
+/**
+ * Context プラグインを作成する
+ */
+export declare function createContextPlugin(): Plugin;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ydant/context",
+  "version": "0.1.0",
+  "description": "Context API for Ydant",
+  "keywords": [
+    "context",
+    "dependency-injection",
+    "state",
+    "ydant"
+  ],
+  "homepage": "https://github.com/cwd-k2/ydant#readme",
+  "bugs": {
+    "url": "https://github.com/cwd-k2/ydant/issues"
+  },
+  "license": "MIT",
+  "author": "cwd-k2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cwd-k2/ydant.git",
+    "directory": "packages/context"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "main": "./dist/index.umd.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "@ydant/dev": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.umd.js"
+    }
+  },
+  "peerDependencies": {
+    "@ydant/base": "0.1.0",
+    "@ydant/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit"
+  }
+}