@xnetjs/data 0.0.2

package/dist/page-O4WTOIEO.js

@@ -0,0 +1,7 @@
+import {
+  PageSchema
+} from "./chunk-GZHARFKC.js";
+import "./chunk-SZC345Z2.js";
+export {
+  PageSchema
+};

package/dist/task-SEKAYJH7.js

@@ -0,0 +1,7 @@
+import {
+  TaskSchema
+} from "./chunk-2L5ZUGG5.js";
+import "./chunk-SZC345Z2.js";
+export {
+  TaskSchema
+};

package/dist/ts-plugin/index.cjs

@@ -0,0 +1,240 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ts-plugin/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  diffSchemaProperties: () => diffSchemaProperties,
+  extractSchemaInfo: () => extractSchemaInfo,
+  isDefineSchemaCall: () => isDefineSchemaCall
+});
+module.exports = __toCommonJS(index_exports);
+function init(modules) {
+  const typescript = modules.typescript;
+  function create(info) {
+    const logger = info.project.projectService.logger;
+    logger.info("[xnet-schema-plugin] Initializing...");
+    const proxy = createLanguageServiceProxy(info.languageService);
+    const schemaCache = /* @__PURE__ */ new Map();
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const prior = info.languageService.getSemanticDiagnostics(fileName);
+      const program = info.languageService.getProgram();
+      if (!program) return prior;
+      const sourceFile = program.getSourceFile(fileName);
+      if (!sourceFile) return prior;
+      const schemaDiagnostics = analyzeSchemaChanges(typescript, sourceFile, schemaCache, logger);
+      return [...prior, ...schemaDiagnostics];
+    };
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+      const prior = info.languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences
+      );
+      const schemaFixes = getSchemaCodeFixes(
+        typescript,
+        info.languageService,
+        fileName,
+        start,
+        end,
+        errorCodes
+      );
+      return [...prior, ...schemaFixes];
+    };
+    logger.info("[xnet-schema-plugin] Ready");
+    return proxy;
+  }
+  return { create };
+}
+function createLanguageServiceProxy(ls) {
+  const proxy = /* @__PURE__ */ Object.create(null);
+  for (const k of Object.keys(ls)) {
+    const x = ls[k];
+    proxy[k] = typeof x === "function" ? x.bind(ls) : x;
+  }
+  return proxy;
+}
+function analyzeSchemaChanges(typescript, sourceFile, schemaCache, _logger) {
+  const diagnostics = [];
+  typescript.forEachChild(sourceFile, function visit(node) {
+    if (isDefineSchemaCall(typescript, node)) {
+      const schemaInfo = extractSchemaInfo(typescript, node, sourceFile);
+      if (schemaInfo) {
+        const cached = schemaCache.get(schemaInfo.name);
+        if (cached && cached.version !== schemaInfo.version) {
+          const changes = diffSchemaProperties(cached, schemaInfo);
+          const breakingChanges = changes.filter((c) => c.risk === "breaking");
+          const cautionChanges = changes.filter((c) => c.risk === "caution");
+          for (const change of breakingChanges) {
+            diagnostics.push({
+              file: sourceFile,
+              start: node.getStart(),
+              length: node.getWidth(),
+              messageText: `Breaking schema change: ${change.description}. ${change.suggestedFix || "Consider adding a migration lens."}`,
+              category: typescript.DiagnosticCategory.Error,
+              code: 90001,
+              // Custom error code
+              source: "xnet-schema-plugin"
+            });
+          }
+          for (const change of cautionChanges) {
+            diagnostics.push({
+              file: sourceFile,
+              start: node.getStart(),
+              length: node.getWidth(),
+              messageText: `Schema change requires attention: ${change.description}`,
+              category: typescript.DiagnosticCategory.Warning,
+              code: 90002,
+              source: "xnet-schema-plugin"
+            });
+          }
+        }
+        schemaCache.set(schemaInfo.name, schemaInfo);
+      }
+    }
+    typescript.forEachChild(node, visit);
+  });
+  return diagnostics;
+}
+function isDefineSchemaCall(typescript, node) {
+  if (!typescript.isCallExpression(node)) return false;
+  const expr = node.expression;
+  if (typescript.isIdentifier(expr) && expr.text === "defineSchema") {
+    return true;
+  }
+  if (typescript.isPropertyAccessExpression(expr) && typescript.isIdentifier(expr.name) && expr.name.text === "defineSchema") {
+    return true;
+  }
+  return false;
+}
+function extractSchemaInfo(typescript, node, _sourceFile) {
+  const args = node.arguments;
+  if (args.length === 0) return null;
+  const configArg = args[0];
+  if (!typescript.isObjectLiteralExpression(configArg)) return null;
+  let name = "";
+  let version = "1.0.0";
+  const properties = /* @__PURE__ */ new Map();
+  for (const prop of configArg.properties) {
+    if (!typescript.isPropertyAssignment(prop)) continue;
+    if (!typescript.isIdentifier(prop.name)) continue;
+    const propName = prop.name.text;
+    if (propName === "name" && typescript.isStringLiteral(prop.initializer)) {
+      name = prop.initializer.text;
+    }
+    if (propName === "version" && typescript.isStringLiteral(prop.initializer)) {
+      version = prop.initializer.text;
+    }
+    if (propName === "properties" && typescript.isObjectLiteralExpression(prop.initializer)) {
+      for (const propDef of prop.initializer.properties) {
+        if (!typescript.isPropertyAssignment(propDef)) continue;
+        if (!typescript.isIdentifier(propDef.name)) continue;
+        const propertyName = propDef.name.text;
+        const propertyInfo = extractPropertyInfo(typescript, propDef.initializer);
+        if (propertyInfo) {
+          properties.set(propertyName, { ...propertyInfo, name: propertyName });
+        }
+      }
+    }
+  }
+  if (!name) return null;
+  return { name, version, properties, location: node };
+}
+function extractPropertyInfo(typescript, node) {
+  if (!typescript.isObjectLiteralExpression(node)) return null;
+  let type = "unknown";
+  let required = false;
+  for (const prop of node.properties) {
+    if (!typescript.isPropertyAssignment(prop)) continue;
+    if (!typescript.isIdentifier(prop.name)) continue;
+    if (prop.name.text === "type" && typescript.isStringLiteral(prop.initializer)) {
+      type = prop.initializer.text;
+    }
+    if (prop.name.text === "required") {
+      required = prop.initializer.kind === typescript.SyntaxKind.TrueKeyword;
+    }
+  }
+  return { type, required };
+}
+function diffSchemaProperties(oldSchema, newSchema) {
+  const changes = [];
+  for (const [name] of oldSchema.properties) {
+    if (!newSchema.properties.has(name)) {
+      changes.push({
+        type: "remove",
+        property: name,
+        risk: "caution",
+        description: `Property "${name}" was removed`,
+        suggestedFix: `Add lens: remove('${name}')`
+      });
+    }
+  }
+  for (const [name, newProp] of newSchema.properties) {
+    if (!oldSchema.properties.has(name)) {
+      changes.push({
+        type: "add",
+        property: name,
+        risk: newProp.required ? "caution" : "safe",
+        description: newProp.required ? `Required property "${name}" was added` : `Optional property "${name}" was added`,
+        suggestedFix: newProp.required ? `Add lens: addDefault('${name}', defaultValue)` : void 0
+      });
+    }
+  }
+  for (const [name, oldProp] of oldSchema.properties) {
+    const newProp = newSchema.properties.get(name);
+    if (!newProp) continue;
+    if (oldProp.type !== newProp.type) {
+      changes.push({
+        type: "modify",
+        property: name,
+        risk: "breaking",
+        description: `Property "${name}" changed type from "${oldProp.type}" to "${newProp.type}"`,
+        suggestedFix: `Add lens: transform('${name}', forwardFn, backwardFn)`
+      });
+    }
+    if (!oldProp.required && newProp.required) {
+      changes.push({
+        type: "modify",
+        property: name,
+        risk: "caution",
+        description: `Property "${name}" became required`,
+        suggestedFix: `Add lens: addDefault('${name}', defaultValue)`
+      });
+    }
+  }
+  return changes;
+}
+function getSchemaCodeFixes(_typescript, _languageService, _fileName, _start, _end, errorCodes) {
+  const fixes = [];
+  if (!errorCodes.includes(90001) && !errorCodes.includes(90002)) {
+    return fixes;
+  }
+  return fixes;
+}
+var index_default = init;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffSchemaProperties,
+  extractSchemaInfo,
+  isDefineSchemaCall
+});

package/dist/ts-plugin/index.d.cts

@@ -0,0 +1,46 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
+
+/**
+ * TypeScript Language Service Plugin for xNet Schema Validation
+ *
+ * This plugin provides:
+ * - Warnings when schema changes are breaking
+ * - Suggestions for migration code
+ * - Quick fixes for common issues
+ *
+ * Usage in tsconfig.json:
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "plugins": [{ "name": "@xnetjs/data/ts-plugin" }]
+ *   }
+ * }
+ * ```
+ */
+
+interface SchemaInfo {
+    name: string;
+    version: string;
+    properties: Map<string, PropertyInfo>;
+    location: ts.Node;
+}
+interface PropertyInfo {
+    name: string;
+    type: string;
+    required: boolean;
+}
+interface SchemaChange {
+    type: 'add' | 'remove' | 'modify' | 'rename';
+    property: string;
+    risk: 'safe' | 'caution' | 'breaking';
+    description: string;
+    suggestedFix?: string;
+}
+declare function init(modules: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;
+declare function isDefineSchemaCall(typescript: typeof ts, node: ts.Node): node is ts.CallExpression;
+declare function extractSchemaInfo(typescript: typeof ts, node: ts.CallExpression, _sourceFile: ts.SourceFile): SchemaInfo | null;
+declare function diffSchemaProperties(oldSchema: SchemaInfo, newSchema: SchemaInfo): SchemaChange[];
+
+export { type PropertyInfo, type SchemaChange, type SchemaInfo, init as default, diffSchemaProperties, extractSchemaInfo, isDefineSchemaCall };

package/dist/ts-plugin/index.d.ts

@@ -0,0 +1,46 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
+
+/**
+ * TypeScript Language Service Plugin for xNet Schema Validation
+ *
+ * This plugin provides:
+ * - Warnings when schema changes are breaking
+ * - Suggestions for migration code
+ * - Quick fixes for common issues
+ *
+ * Usage in tsconfig.json:
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "plugins": [{ "name": "@xnetjs/data/ts-plugin" }]
+ *   }
+ * }
+ * ```
+ */
+
+interface SchemaInfo {
+    name: string;
+    version: string;
+    properties: Map<string, PropertyInfo>;
+    location: ts.Node;
+}
+interface PropertyInfo {
+    name: string;
+    type: string;
+    required: boolean;
+}
+interface SchemaChange {
+    type: 'add' | 'remove' | 'modify' | 'rename';
+    property: string;
+    risk: 'safe' | 'caution' | 'breaking';
+    description: string;
+    suggestedFix?: string;
+}
+declare function init(modules: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;
+declare function isDefineSchemaCall(typescript: typeof ts, node: ts.Node): node is ts.CallExpression;
+declare function extractSchemaInfo(typescript: typeof ts, node: ts.CallExpression, _sourceFile: ts.SourceFile): SchemaInfo | null;
+declare function diffSchemaProperties(oldSchema: SchemaInfo, newSchema: SchemaInfo): SchemaChange[];
+
+export { type PropertyInfo, type SchemaChange, type SchemaInfo, init as default, diffSchemaProperties, extractSchemaInfo, isDefineSchemaCall };

package/dist/ts-plugin/index.js

@@ -0,0 +1,213 @@
+// src/ts-plugin/index.ts
+function init(modules) {
+  const typescript = modules.typescript;
+  function create(info) {
+    const logger = info.project.projectService.logger;
+    logger.info("[xnet-schema-plugin] Initializing...");
+    const proxy = createLanguageServiceProxy(info.languageService);
+    const schemaCache = /* @__PURE__ */ new Map();
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const prior = info.languageService.getSemanticDiagnostics(fileName);
+      const program = info.languageService.getProgram();
+      if (!program) return prior;
+      const sourceFile = program.getSourceFile(fileName);
+      if (!sourceFile) return prior;
+      const schemaDiagnostics = analyzeSchemaChanges(typescript, sourceFile, schemaCache, logger);
+      return [...prior, ...schemaDiagnostics];
+    };
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+      const prior = info.languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences
+      );
+      const schemaFixes = getSchemaCodeFixes(
+        typescript,
+        info.languageService,
+        fileName,
+        start,
+        end,
+        errorCodes
+      );
+      return [...prior, ...schemaFixes];
+    };
+    logger.info("[xnet-schema-plugin] Ready");
+    return proxy;
+  }
+  return { create };
+}
+function createLanguageServiceProxy(ls) {
+  const proxy = /* @__PURE__ */ Object.create(null);
+  for (const k of Object.keys(ls)) {
+    const x = ls[k];
+    proxy[k] = typeof x === "function" ? x.bind(ls) : x;
+  }
+  return proxy;
+}
+function analyzeSchemaChanges(typescript, sourceFile, schemaCache, _logger) {
+  const diagnostics = [];
+  typescript.forEachChild(sourceFile, function visit(node) {
+    if (isDefineSchemaCall(typescript, node)) {
+      const schemaInfo = extractSchemaInfo(typescript, node, sourceFile);
+      if (schemaInfo) {
+        const cached = schemaCache.get(schemaInfo.name);
+        if (cached && cached.version !== schemaInfo.version) {
+          const changes = diffSchemaProperties(cached, schemaInfo);
+          const breakingChanges = changes.filter((c) => c.risk === "breaking");
+          const cautionChanges = changes.filter((c) => c.risk === "caution");
+          for (const change of breakingChanges) {
+            diagnostics.push({
+              file: sourceFile,
+              start: node.getStart(),
+              length: node.getWidth(),
+              messageText: `Breaking schema change: ${change.description}. ${change.suggestedFix || "Consider adding a migration lens."}`,
+              category: typescript.DiagnosticCategory.Error,
+              code: 90001,
+              // Custom error code
+              source: "xnet-schema-plugin"
+            });
+          }
+          for (const change of cautionChanges) {
+            diagnostics.push({
+              file: sourceFile,
+              start: node.getStart(),
+              length: node.getWidth(),
+              messageText: `Schema change requires attention: ${change.description}`,
+              category: typescript.DiagnosticCategory.Warning,
+              code: 90002,
+              source: "xnet-schema-plugin"
+            });
+          }
+        }
+        schemaCache.set(schemaInfo.name, schemaInfo);
+      }
+    }
+    typescript.forEachChild(node, visit);
+  });
+  return diagnostics;
+}
+function isDefineSchemaCall(typescript, node) {
+  if (!typescript.isCallExpression(node)) return false;
+  const expr = node.expression;
+  if (typescript.isIdentifier(expr) && expr.text === "defineSchema") {
+    return true;
+  }
+  if (typescript.isPropertyAccessExpression(expr) && typescript.isIdentifier(expr.name) && expr.name.text === "defineSchema") {
+    return true;
+  }
+  return false;
+}
+function extractSchemaInfo(typescript, node, _sourceFile) {
+  const args = node.arguments;
+  if (args.length === 0) return null;
+  const configArg = args[0];
+  if (!typescript.isObjectLiteralExpression(configArg)) return null;
+  let name = "";
+  let version = "1.0.0";
+  const properties = /* @__PURE__ */ new Map();
+  for (const prop of configArg.properties) {
+    if (!typescript.isPropertyAssignment(prop)) continue;
+    if (!typescript.isIdentifier(prop.name)) continue;
+    const propName = prop.name.text;
+    if (propName === "name" && typescript.isStringLiteral(prop.initializer)) {
+      name = prop.initializer.text;
+    }
+    if (propName === "version" && typescript.isStringLiteral(prop.initializer)) {
+      version = prop.initializer.text;
+    }
+    if (propName === "properties" && typescript.isObjectLiteralExpression(prop.initializer)) {
+      for (const propDef of prop.initializer.properties) {
+        if (!typescript.isPropertyAssignment(propDef)) continue;
+        if (!typescript.isIdentifier(propDef.name)) continue;
+        const propertyName = propDef.name.text;
+        const propertyInfo = extractPropertyInfo(typescript, propDef.initializer);
+        if (propertyInfo) {
+          properties.set(propertyName, { ...propertyInfo, name: propertyName });
+        }
+      }
+    }
+  }
+  if (!name) return null;
+  return { name, version, properties, location: node };
+}
+function extractPropertyInfo(typescript, node) {
+  if (!typescript.isObjectLiteralExpression(node)) return null;
+  let type = "unknown";
+  let required = false;
+  for (const prop of node.properties) {
+    if (!typescript.isPropertyAssignment(prop)) continue;
+    if (!typescript.isIdentifier(prop.name)) continue;
+    if (prop.name.text === "type" && typescript.isStringLiteral(prop.initializer)) {
+      type = prop.initializer.text;
+    }
+    if (prop.name.text === "required") {
+      required = prop.initializer.kind === typescript.SyntaxKind.TrueKeyword;
+    }
+  }
+  return { type, required };
+}
+function diffSchemaProperties(oldSchema, newSchema) {
+  const changes = [];
+  for (const [name] of oldSchema.properties) {
+    if (!newSchema.properties.has(name)) {
+      changes.push({
+        type: "remove",
+        property: name,
+        risk: "caution",
+        description: `Property "${name}" was removed`,
+        suggestedFix: `Add lens: remove('${name}')`
+      });
+    }
+  }
+  for (const [name, newProp] of newSchema.properties) {
+    if (!oldSchema.properties.has(name)) {
+      changes.push({
+        type: "add",
+        property: name,
+        risk: newProp.required ? "caution" : "safe",
+        description: newProp.required ? `Required property "${name}" was added` : `Optional property "${name}" was added`,
+        suggestedFix: newProp.required ? `Add lens: addDefault('${name}', defaultValue)` : void 0
+      });
+    }
+  }
+  for (const [name, oldProp] of oldSchema.properties) {
+    const newProp = newSchema.properties.get(name);
+    if (!newProp) continue;
+    if (oldProp.type !== newProp.type) {
+      changes.push({
+        type: "modify",
+        property: name,
+        risk: "breaking",
+        description: `Property "${name}" changed type from "${oldProp.type}" to "${newProp.type}"`,
+        suggestedFix: `Add lens: transform('${name}', forwardFn, backwardFn)`
+      });
+    }
+    if (!oldProp.required && newProp.required) {
+      changes.push({
+        type: "modify",
+        property: name,
+        risk: "caution",
+        description: `Property "${name}" became required`,
+        suggestedFix: `Add lens: addDefault('${name}', defaultValue)`
+      });
+    }
+  }
+  return changes;
+}
+function getSchemaCodeFixes(_typescript, _languageService, _fileName, _start, _end, errorCodes) {
+  const fixes = [];
+  if (!errorCodes.includes(90001) && !errorCodes.includes(90002)) {
+    return fixes;
+  }
+  return fixes;
+}
+var index_default = init;
+export {
+  index_default as default,
+  diffSchemaProperties,
+  extractSchemaInfo,
+  isDefineSchemaCall
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@xnetjs/data",
+  "version": "0.0.2",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crs48/xNet"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./ts-plugin": {
+      "types": "./dist/ts-plugin/index.d.ts",
+      "require": "./dist/ts-plugin/index.cjs",
+      "import": "./dist/ts-plugin/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "lib0": "^0.2.102",
+    "nanoid": "^5.1.6",
+    "y-protocols": "^1.0.6",
+    "yjs": "^13.6.24",
+    "@xnetjs/core": "0.0.2",
+    "@xnetjs/crypto": "0.0.2",
+    "@xnetjs/identity": "0.0.2",
+    "@xnetjs/sqlite": "0.0.2",
+    "@xnetjs/storage": "0.0.2",
+    "@xnetjs/sync": "0.0.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts && tsup src/ts-plugin/index.ts --format cjs,esm --dts --outDir dist/ts-plugin",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}