@almadar/std 1.0.0

package/dist/types-I95R8_FN.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Standard Library Types
+ *
+ * Common types and interfaces for the Orbital Standard Library.
+ * Extends the core operator system with std-prefixed modules.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Operator categories for the core expression language.
+ */
+declare const OPERATOR_CATEGORIES: readonly ["arithmetic", "comparison", "logic", "control", "effect", "collection", "std-math", "std-str", "std-array", "std-object", "std-validate", "std-time", "std-format", "std-async", "std-nn", "std-tensor", "std-train"];
+type OperatorCategory = (typeof OPERATOR_CATEGORIES)[number];
+/**
+ * Base metadata for an operator.
+ */
+interface OperatorMeta {
+    /** Operator category */
+    category: OperatorCategory;
+    /** Minimum number of arguments */
+    minArity: number;
+    /** Maximum number of arguments (null = unlimited) */
+    maxArity: number | null;
+    /** Human-readable description */
+    description: string;
+    /** Whether this operator has side effects (only valid in effect context) */
+    hasSideEffects: boolean;
+    /** Return type hint - basic types for core operators, extended types for std modules */
+    returnType: string;
+}
+/**
+ * Standard library module names.
+ * Each module provides a set of operators prefixed with the module name.
+ * E.g., 'math' provides 'math/abs', 'math/clamp', etc.
+ */
+declare const STD_MODULES: readonly ["math", "str", "array", "object", "time", "validate", "format", "async", "nn", "tensor", "train"];
+type StdModule = (typeof STD_MODULES)[number];
+/**
+ * Standard library operator categories.
+ * These extend the core categories for more granular classification.
+ */
+declare const STD_OPERATOR_CATEGORIES: readonly ["std-math", "std-str", "std-array", "std-object", "std-time", "std-validate", "std-format", "std-async", "std-nn", "std-tensor", "std-train"];
+type StdOperatorCategory = (typeof STD_OPERATOR_CATEGORIES)[number];
+/**
+ * Extended operator metadata for std library operators.
+ * Adds parameter descriptions and examples.
+ */
+interface StdOperatorMeta extends OperatorMeta {
+    /** The std module this operator belongs to */
+    module: StdModule;
+    /** Parameter names and descriptions */
+    params?: {
+        name: string;
+        type: string;
+        description: string;
+        optional?: boolean;
+        defaultValue?: unknown;
+    }[];
+    /** Example usage */
+    example?: string;
+    /** Whether this operator accepts a lambda expression argument */
+    acceptsLambda?: boolean;
+    /** Position of the lambda argument (0-indexed) */
+    lambdaArgPosition?: number;
+}
+/**
+ * Type guard to check if an operator category is a std category.
+ */
+declare function isStdCategory(category: string): category is StdOperatorCategory;
+/**
+ * Get the module name from a std operator name.
+ * E.g., 'math/clamp' -> 'math'
+ */
+declare function getModuleFromOperator(operator: string): StdModule | null;
+/**
+ * Get the function name from a std operator.
+ * E.g., 'math/clamp' -> 'clamp'
+ */
+declare function getFunctionFromOperator(operator: string): string | null;
+/**
+ * Check if an operator name is a std library operator.
+ * Std library operators are prefixed with their module name (e.g., 'math/', 'str/').
+ */
+declare function isStdOperator(operator: string): boolean;
+/**
+ * Create a std operator name from module and function name.
+ * E.g., ('math', 'clamp') -> 'math/clamp'
+ */
+declare function makeStdOperator(module: StdModule, fn: string): string;
+
+export { type StdModule as S, type StdOperatorMeta as a, STD_MODULES as b, STD_OPERATOR_CATEGORIES as c, type StdOperatorCategory as d, getModuleFromOperator as e, isStdOperator as f, getFunctionFromOperator as g, isStdCategory as i, makeStdOperator as m };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@almadar/std",
+  "version": "1.0.0",
+  "description": "Standard library operators for Almadar (math, string, array, etc.)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./modules/*": {
+      "import": "./dist/modules/*.js",
+      "types": "./dist/modules/*.d.ts"
+    },
+    "./behaviors/*": {
+      "import": "./dist/behaviors/*.js",
+      "types": "./dist/behaviors/*.d.ts"
+    },
+    "./registry": {
+      "import": "./dist/registry.js",
+      "types": "./dist/registry.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@almadar/core": "1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.4.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/almadar-io/almadar.git",
+    "directory": "packages/almadar-std"
+  },
+  "license": "MIT",
+  "keywords": [
+    "almadar",
+    "std",
+    "standard-library",
+    "operators"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}