semanticdb-v2 2.0.0-alpha.1

package/dist/semantic-types/builtins/object.js

@@ -0,0 +1 @@
+const r=(e,{property:t,requestEntity:n})=>!t.ref||e===void 0||e===null||typeof e=="object"&&!Array.isArray(e)?e:n(t.ref,e),c={name:"object",primalType:"object",hydrateResult:r};export{r as hydrateObjectResult,c as objectSemanticType};

package/dist/semantic-types/builtins/order.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeDefinition } from '../types';
+export declare const orderSemanticType: SemanticTypeDefinition;

package/dist/semantic-types/builtins/order.js

@@ -0,0 +1 @@
+const e={name:"order",primalType:"number"};export{e as orderSemanticType};

package/dist/semantic-types/builtins/percentage.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeDefinition } from '../types';
+export declare const percentageSemanticType: SemanticTypeDefinition;

package/dist/semantic-types/builtins/percentage.js

@@ -0,0 +1 @@
+const e={name:"percentage",primalType:"number"};export{e as percentageSemanticType};

package/dist/semantic-types/builtins/start-date.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeDefinition } from '../types';
+export declare const startDateSemanticType: SemanticTypeDefinition;

package/dist/semantic-types/builtins/start-date.js

@@ -0,0 +1 @@
+const t={name:"start_date",primalType:"date"};export{t as startDateSemanticType};

package/dist/semantic-types/builtins/string.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeDefinition } from '../types';
+export declare const stringSemanticType: SemanticTypeDefinition;

package/dist/semantic-types/builtins/string.js

@@ -0,0 +1 @@
+const n={name:"string",primalType:"string"};export{n as stringSemanticType};

package/dist/semantic-types/builtins/timestamp.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeDefinition } from '../types';
+export declare const timestampSemanticType: SemanticTypeDefinition;

package/dist/semantic-types/builtins/timestamp.js

@@ -0,0 +1 @@
+const e={name:"timestamp",primalType:"date"};export{e as timestampSemanticType};

package/dist/semantic-types/index.d.ts

@@ -0,0 +1,9 @@
+import { SemanticTypeRegistry } from './registry';
+export { builtinSemanticTypes } from './builtins/index';
+export { SemanticTypeRegistry } from './registry';
+export { resolveSchema } from './resolve-schema';
+export { validateResolvedSchema } from './validate-resolved-schema';
+export { normalizePrimalQuery } from './primal-types/index';
+export type { ComparableCategoryDefinition, PropertySqlDefinition, PrimalType, ResolvedSemanticProperty, ResolvedSemanticSchema, LegacySemanticSchemaMetadata, ResolvedSemanticSchemaMetadata, SemanticSchemaMetadata, SemanticTypeNormalizeContext, SemanticPeriodEvaluationContext, SemanticTypeResultContext, SemanticTypeResultProperty, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, TimeGranularity, TemporalSemantics, } from './types';
+export type { HierarchyDefinition, HierarchyLevelDefinition, ResolvedHierarchyDefinition, } from '../plugins/hierarchy/index';
+export declare const createSemanticTypeRegistry: () => SemanticTypeRegistry;

package/dist/semantic-types/index.js

@@ -0,0 +1 @@
+import{builtinSemanticTypes as e}from"./builtins/index.js";import{SemanticTypeRegistry as t}from"./registry.js";import"./primal-types/date.js";const i=()=>new t(e);export{t as SemanticTypeRegistry,e as builtinSemanticTypes,i as createSemanticTypeRegistry};

package/dist/semantic-types/primal-types/date.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeNormalizeContext } from '../types';
+export declare const normalizeDateQuery: (value: unknown, context: SemanticTypeNormalizeContext) => Promise<unknown>;

package/dist/semantic-types/primal-types/date.js

@@ -0,0 +1 @@
+import o from"dayjs";import b from"dayjs/plugin/customParseFormat.js";import A from"dayjs/plugin/isoWeek.js";import k from"dayjs/plugin/quarterOfYear.js";import{SemanticDBError as p}from"../../errors.js";import{isLogicform as O}from"../../logicform-types.js";o.extend(b),o.extend(A),o.extend(k);const U="YYYY-MM-DD HH:mm:ss",h=new Set(["YTD","QTD","MTD","WTD","DTD"]),q=new Set(["$eq","$gt","$gte","$lt","$lte","$in","$nin","$and","$or"]),$=["second","minute","hour","day","week","month","quarter","year"],a=t=>Object.prototype.toString.call(t)==="[object Object]",D=t=>!a(t)||"$gte"in t||"$gt"in t||"$lte"in t||"$lt"in t||"$or"in t||"$ne"in t?!1:typeof t.granularity=="string"&&$.includes(t.granularity)&&typeof t.offset=="number"||$.some(r=>r in t),c=t=>o(t).format(U),P=(t,r)=>$.find(n=>n in t||r!==void 0),E=(t,r,n)=>r==="month"?t.month(n-1):r==="day"?t.date(n):r==="week"?t.isoWeek(n):r==="quarter"?t.quarter(n):t.set(r,n),l=(t,r)=>{const n=typeof t.granularity=="string"?t.granularity:void 0,e=n?{[n]:t.offset}:void 0,i=n??P(t,void 0)??"day";let s=o(r).millisecond(0);for(const f of[...$].reverse()){const d=t[f];typeof d=="number"&&(s=E(s,f,d));const m=e?.[f];typeof m=="number"&&m!==0&&(s=s.add(m,f))}const y=i==="week"?"isoWeek":i;return{$gte:c(s.startOf(y)),$lte:c(s.endOf(y))}},R=(t,r)=>{const n=o(r),i={DTD:()=>n.startOf("day"),WTD:()=>n.startOf("isoWeek"),MTD:()=>n.startOf("month"),QTD:()=>n.startOf("quarter"),YTD:()=>n.startOf("year")}[t];return{$gte:c(i()),$lte:c(n.endOf("day"))}},w=async(t,r)=>{const n=o(String(t.$lte)),e=o(r.now).endOf("day");if(!n.isAfter(e))return t;const s=await r.requestLatestDataDate()??r.now,y=r.property.granularity??"day",f=y==="week"?"isoWeek":y,d=o(s).endOf(f),m=d.isBefore(n)?d:n;return{...t,$lte:c(m)}},u=async(t,r)=>O(t)?t:t instanceof Date||typeof t=="string"&&o(t).isValid()?c(t):typeof t=="string"&&h.has(t)?w(R(t,r.now),r):D(t)?w(l(t,r.now),r):t,T=async(t,r,n)=>{if(t==="$and"||t==="$or")return Array.isArray(r)?Promise.all(r.map(i=>g(i,n))):r;if(Array.isArray(r))return Promise.all(r.map(i=>u(i,n)));const e=await u(r,n);return t==="$eq"&&a(e)&&"$gte"in e&&"$lte"in e?e:t==="$gte"||t==="$gt"?a(e)&&"$gte"in e?e.$gte:e:(t==="$lte"||t==="$lt")&&a(e)&&"$lte"in e?e.$lte:e},g=async(t,r)=>{if(O(t))return t;if(Array.isArray(t))return Promise.all(t.map(i=>g(i,r)));if(!a(t))return u(t,r);if("$options"in t)throw new p("UNSUPPORTED_QUERY_OPERATOR","$options is a LogicForm 1.x field; use args.options in LogicForm 2.0");if("$offset"in t)throw new p("UNSUPPORTED_DATE_VALUE","The legacy {$offset: ...} date form is not supported; use { granularity, offset }");if(("granularity"in t||"offset"in t)&&(!D(t)||!Number.isInteger(t.offset)))throw new p("INVALID_DATE_VALUE","Relative date values require one granularity and an integer offset");if(D(t))return w(l(t,r.now),r);const n=Object.entries(t);if(n.length===1&&n[0]?.[0]==="$eq"){const i=await T("$eq",n[0][1],r);if(a(i)&&"$gte"in i&&"$lte"in i)return i}const e={};for(const[i,s]of n)e[i]=q.has(i)?await T(i,s,r):await g(s,r);return e};export{g as normalizeDateQuery};

package/dist/semantic-types/primal-types/index.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticTypeNormalizeContext } from '../types';
+export declare const normalizePrimalQuery: (value: unknown, context: SemanticTypeNormalizeContext) => unknown;

package/dist/semantic-types/primal-types/index.js

@@ -0,0 +1 @@
+import{normalizeDateQuery as t}from"./date.js";const i=(r,e)=>e.property.primal_type==="date"?t(r,e):r;export{i as normalizePrimalQuery};

package/dist/semantic-types/registry.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedSemanticProperty, ResolvedSemanticSchema, SemanticTypeDefinition } from './types';
+import type { LogicformType, PredItemType } from '../logicform-types';
+export declare class SemanticTypeRegistry {
+    #private;
+    constructor(definitions?: readonly SemanticTypeDefinition[]);
+    register(definition: SemanticTypeDefinition): this;
+    get(name: string): SemanticTypeDefinition;
+    requiresPerPeriodEvaluation(context: {
+        readonly logicform: LogicformType;
+        readonly pred: PredItemType;
+        readonly schema: ResolvedSemanticSchema;
+        readonly property?: ResolvedSemanticProperty;
+    }): boolean;
+}

package/dist/semantic-types/registry.js

@@ -0,0 +1 @@
+import{SemanticDBError as t}from"../errors.js";class s{#e=new Map;constructor(e=[]){for(const r of e)this.register(r)}register(e){if(!e.name)throw new t("INVALID_SEMANTIC_TYPE","Semantic type name must not be empty");if(this.#e.has(e.name))throw new t("SEMANTIC_TYPE_ALREADY_REGISTERED",`Semantic type is already registered: ${e.name}`,{type:e.name});return this.#e.set(e.name,e),this}get(e){const r=this.#e.get(e);if(!r)throw new t("SEMANTIC_TYPE_NOT_FOUND",`Semantic type is not registered: ${e}`,{type:e});return r}requiresPerPeriodEvaluation(e){return e.property?this.get(e.property.type).requiresPerPeriodEvaluation?.({...e,property:e.property})??!1:!1}}export{s as SemanticTypeRegistry};

package/dist/semantic-types/resolve-schema.d.ts

@@ -0,0 +1,4 @@
+import type { SemanticDBPlugin } from '../plugins/index';
+import type { SemanticTypeRegistry } from './registry';
+import type { ResolvedSemanticSchema, SemanticSchemaDraft } from './types';
+export declare const resolveSchema: (schema: SemanticSchemaDraft, registry: SemanticTypeRegistry, externalPlugins?: readonly SemanticDBPlugin[]) => ResolvedSemanticSchema;

package/dist/semantic-types/resolve-schema.js

@@ -0,0 +1 @@
+import{SemanticDBError as i}from"../errors.js";import{resolvePlugins as f}from"../plugins/index.js";import{validateResolvedSchema as y}from"./validate-resolved-schema.js";const c=new Set(["hour","day","week","month","quarter","year"]),A=(e,l)=>{if("_id"in e||"_sid"in e)throw new i("LEGACY_PROPERTY_ID_NOT_ALLOWED",`Property ${e.name} must use id instead of _id; _sid is not supported`,{property:e.name});if("sid"in e)throw new i("PROPERTY_SID_NOT_ALLOWED",`Property ${e.name} must not declare sid`,{property:e.name});const m=e;if(m.is_comparable!==void 0||m.comparable_order!==void 0)throw new i("LEGACY_COMPARABLE_NOT_ALLOWED",`Property ${e.name} must use comparable instead of is_comparable/comparable_order`,{property:e.name});if(e.udf!==void 0){const r=e.udf;if(typeof r!="object"||r===null||Array.isArray(r))throw new i("INVALID_PROPERTY_UDF",`Property ${e.name} udf must be an object containing only sql`,{property:e.name});const n=r,o=Object.keys(n).filter(d=>d!=="sql");if(o.length>0)throw new i("UNSUPPORTED_PROPERTY_UDF",`Property ${e.name} udf only supports sql`,{property:e.name,unsupportedKeys:o});if(typeof n.sql!="string"||n.sql.trim().length===0)throw new i("INVALID_PROPERTY_UDF",`Property ${e.name} udf.sql must be a non-empty string`,{property:e.name})}const s=l.get(e.type);if(e.primal_type!==void 0&&e.primal_type!==s.primalType)throw new i("PRIMAL_TYPE_MISMATCH",`Property ${e.name} declares primal_type ${e.primal_type}, but ${e.type} requires ${s.primalType}`,{property:e.name,type:e.type,declared:e.primal_type,expected:s.primalType});if(e.isArray!==void 0&&typeof e.isArray!="boolean")throw new i("INVALID_IS_ARRAY",`Property ${e.name} isArray must be a boolean`,{property:e.name,isArray:e.isArray});if("is_observation"in e)throw new i("LEGACY_TEMPORAL_SEMANTICS_NOT_ALLOWED",`Property ${e.name} must use Schema temporalSemantics; is_observation is not supported`,{property:e.name});if(e.comparable!==void 0){const r=e.comparable;if(typeof r!="object"||r===null||Array.isArray(r))throw new i("INVALID_COMPARABLE_CATEGORY",`Property ${e.name} comparable must contain values and direction`);const n=r;if(Object.keys(n).some(o=>o!=="values"&&o!=="direction")||!Array.isArray(n.values)||n.values.length===0||n.values.some(o=>typeof o!="string")||new Set(n.values).size!==n.values.length||n.direction!==1&&n.direction!==-1)throw new i("INVALID_COMPARABLE_CATEGORY",`Property ${e.name} comparable requires unique string values and direction 1 or -1`,{property:e.name,comparable:r});if(e.type!=="category"||e.isArray===!0)throw new i("COMPARABLE_CATEGORY_REQUIRED",`Property ${e.name} comparable is only supported by scalar category properties`,{property:e.name,type:e.type})}const t={...e,id:e.id??e.name,primal_type:s.primalType,isArray:e.isArray??!1,is_dynamic:e.udf?.sql!==void 0,...s.primalType==="date"?{granularity:e.granularity??"day"}:{}};if(s.primalType==="object"){if(typeof t.ref!="string"||t.ref.length===0)throw new i("PROPERTY_REF_REQUIRED",`Object property ${t.name} must declare ref`,{property:t.name,type:t.type})}else if(t.ref!==void 0)throw new i("PROPERTY_REF_NOT_ALLOWED",`Property ${t.name} cannot declare ref unless its primal_type is object`,{property:t.name,type:t.type});if(s.primalType==="date"){if(t.granularity!==void 0&&!c.has(t.granularity))throw new i("INVALID_GRANULARITY",`Property ${t.name} has unsupported granularity: ${t.granularity}`,{property:t.name,granularity:t.granularity})}else if(t.granularity!==void 0)throw new i("GRANULARITY_NOT_ALLOWED",`Property ${t.name} cannot declare granularity unless its primal_type is date`,{property:t.name,type:t.type});return s.validateProperty?.(t),t},P=(e,l,m=[])=>{const s=f(m);if("_id"in e||"_sid"in e)throw new i("LEGACY_SCHEMA_ID_NOT_ALLOWED","Schema must use id instead of _id; _sid is not supported");if("sid"in e)throw new i("SCHEMA_SID_NOT_ALLOWED","Schema must not declare sid");if("is_snapshot"in e||"is_observation"in e)throw new i("LEGACY_TEMPORAL_SEMANTICS_NOT_ALLOWED","Schema must use temporalSemantics instead of is_snapshot/is_observation",{schemaId:e.id});const t=e.temporalSemantics??"normal";if(t!=="normal"&&t!=="snapshot")throw new i("INVALID_TEMPORAL_SEMANTICS","Schema temporalSemantics must be normal or snapshot",{schemaId:e.id,temporalSemantics:t});const r=t;if(!e.id)throw new i("INVALID_SCHEMA_ID","Schema id must not be empty");let n=e.properties.map(a=>A(a,l));if(e.type==="entity"&&!n.some(({type:a})=>a==="timestamp")&&n.some(({type:a})=>a==="start_date")&&n.some(({type:a})=>a==="end_date")&&!n.some(({name:a})=>a==="\u65E5\u671F")){const a=n.find(({type:u})=>u==="start_date");a&&(n=[...n,{id:"__chatbi__timestamp__placeholder__",name:"\u65E5\u671F",type:"timestamp",primal_type:"date",isArray:!1,is_dynamic:!0,is_supplementary:!0,udf:{sql:a.id}}])}y(n,{temporalSemantics:r,schemaId:e.id});const o=s.flatMap(a=>a.schemaMetadata?[a.schemaMetadata]:[]);let d={};for(const a of o)d={...d,...a.resolve(e,n)};const _=e.parentProperty===void 0?void 0:n.find(({id:a,name:u})=>a===e.parentProperty||u===e.parentProperty);if(e.parentProperty!==void 0&&!_)throw new i("RECURSIVE_PARENT_PROPERTY_REQUIRED",`Schema parentProperty does not exist: ${e.parentProperty}`,{schemaId:e.id,property:e.parentProperty});const p=new Set(s.flatMap(a=>[...a.schemaMetadata?.keys??[],...a.legacySchemaKeys??[]]));return{...Object.fromEntries(Object.entries(e).filter(([a])=>a!=="parentProperty"&&!p.has(a))),temporalSemantics:r,properties:n,...d,..._?{parentProperty:_.name}:{}}};export{P as resolveSchema};

package/dist/semantic-types/types.d.ts

@@ -0,0 +1,90 @@
+import type { PropertyTypeDraft, SchemaTypeDraft } from 'semanticdb-core';
+import type { LogicformType, PredItemType } from '../logicform-types';
+export type PrimalType = 'string' | 'number' | 'boolean' | 'date' | 'object';
+export type TimeGranularity = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+export type TemporalSemantics = 'normal' | 'snapshot';
+export interface PropertySqlDefinition {
+    readonly sql: string;
+}
+export interface ComparableCategoryDefinition {
+    readonly values: readonly string[];
+    readonly direction: 1 | -1;
+}
+/** Extension point for plugin-owned Schema draft metadata. */
+export interface SemanticSchemaMetadata {
+}
+/** Extension point for plugin-owned resolved Schema metadata. */
+export interface ResolvedSemanticSchemaMetadata {
+}
+/** Extension point for legacy plugin metadata removed from the canonical Schema shape. */
+export interface LegacySemanticSchemaMetadata {
+}
+export interface SemanticPropertyDraft extends Omit<PropertyTypeDraft, '_id' | '_sid' | 'id' | 'sid' | 'type' | 'primal_type' | 'isArray' | 'granularity' | 'is_observation' | 'is_snapshot' | 'temporalSemantics' | 'is_dynamic' | 'udf' | 'is_comparable' | 'comparable_order'> {
+    readonly id?: string;
+    readonly type: string;
+    readonly primal_type?: PrimalType;
+    readonly isArray?: boolean;
+    readonly granularity?: TimeGranularity;
+    /** Derived during schema resolution from whether the property has udf.sql. */
+    readonly is_dynamic?: boolean;
+    readonly udf?: PropertySqlDefinition;
+    readonly comparable?: ComparableCategoryDefinition;
+}
+export interface ResolvedSemanticProperty extends Omit<SemanticPropertyDraft, 'id' | 'primal_type' | 'isArray' | 'is_dynamic'> {
+    readonly id: string;
+    readonly primal_type: PrimalType;
+    readonly isArray: boolean;
+    readonly is_dynamic?: boolean;
+}
+export interface SemanticSchemaDraft extends Omit<SchemaTypeDraft, '_id' | 'id' | 'sid' | 'properties' | 'db' | 'from' | 'fromSQL' | 'projections' | keyof SemanticSchemaMetadata | keyof LegacySemanticSchemaMetadata>, SemanticSchemaMetadata {
+    readonly [key: string]: unknown;
+    readonly id: string;
+    readonly properties: readonly SemanticPropertyDraft[];
+    readonly temporalSemantics?: TemporalSemantics;
+    /** Property that stores the parent node id for recursive tree queries. */
+    readonly parentProperty?: string;
+}
+export interface ResolvedSemanticSchema extends Omit<SchemaTypeDraft, '_id' | 'id' | 'sid' | 'properties' | 'db' | 'from' | 'fromSQL' | 'projections' | keyof SemanticSchemaMetadata | keyof LegacySemanticSchemaMetadata>, ResolvedSemanticSchemaMetadata {
+    readonly [key: string]: unknown;
+    readonly id: string;
+    readonly properties: readonly ResolvedSemanticProperty[];
+    readonly temporalSemantics?: TemporalSemantics;
+    /** Canonical logical name of the parent Property used by recursive tree queries. */
+    readonly parentProperty?: string;
+}
+export interface SemanticTypeNormalizeContext {
+    readonly schema: ResolvedSemanticSchema;
+    readonly property: ResolvedSemanticProperty;
+    readonly now: Date;
+    readonly requestLatestDataDate: () => Promise<Date | undefined>;
+}
+/** Context used when deciding whether a value must be evaluated per time period. */
+export interface SemanticPeriodEvaluationContext {
+    readonly logicform: LogicformType;
+    readonly pred: PredItemType;
+    readonly schema: ResolvedSemanticSchema;
+    readonly property: ResolvedSemanticProperty;
+}
+export interface SemanticTypeResultProperty {
+    readonly name: string;
+    readonly type: string;
+    readonly primal_type: PrimalType;
+    readonly isArray: boolean;
+    readonly ref?: string;
+    readonly comparable?: ComparableCategoryDefinition;
+}
+export interface SemanticTypeResultContext {
+    readonly property: SemanticTypeResultProperty;
+    /** Batch-aware entity lookup supplied by the executor's Result Hydrator. */
+    readonly requestEntity: (schemaId: string, id: unknown) => Promise<unknown>;
+}
+export interface SemanticTypeDefinition {
+    readonly name: string;
+    readonly primalType: PrimalType;
+    readonly validateProperty?: (property: ResolvedSemanticProperty) => void;
+    /** Whether this semantic property requires one evaluation per time bucket. */
+    readonly requiresPerPeriodEvaluation?: (context: SemanticPeriodEvaluationContext) => boolean;
+    /** Hydrate a physical result value before it is exposed by ExecuteResult. */
+    readonly hydrateResult?: (value: unknown, context: SemanticTypeResultContext) => unknown;
+    readonly normalizeQuery?: (value: unknown, context: SemanticTypeNormalizeContext) => unknown;
+}

package/dist/semantic-types/validate-resolved-schema.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedSemanticProperty, TemporalSemantics } from './types';
+/** Validates invariants that require the complete set of resolved Properties. */
+export declare const validateResolvedSchema: (properties: readonly ResolvedSemanticProperty[], options?: {
+    readonly temporalSemantics?: TemporalSemantics;
+    readonly schemaId?: string;
+}) => void;

package/dist/semantic-types/validate-resolved-schema.js

@@ -0,0 +1 @@
+import{SemanticDBError as a}from"../errors.js";const m=o=>{const r=new Set,t=new Set;for(const e of o){if(!e.name)throw new a("INVALID_PROPERTY_NAME","Property name must not be empty");if(!e.id)throw new a("INVALID_PROPERTY_ID",`Property ${e.name} physical id must not be empty`);if(r.has(e.name))throw new a("DUPLICATE_PROPERTY_NAME",`Duplicate property name: ${e.name}`,{property:e.name});if(t.has(e.id))throw new a("DUPLICATE_PROPERTY_ID",`Duplicate property physical id: ${e.id}`,{propertyId:e.id});r.add(e.name),t.add(e.id)}},n=(o,r={})=>{m(o);const t=o.filter(({type:e})=>e==="timestamp");if(t.length>1)throw new a("MULTIPLE_TIMESTAMP_PROPERTIES","A Schema can declare at most one timestamp Property",{properties:t.map(({name:e})=>e)});if(r.temporalSemantics==="snapshot"&&t.length===0)throw new a("SNAPSHOT_TIMESTAMP_REQUIRED","A snapshot Schema must declare exactly one timestamp Property",{schemaId:r.schemaId})};export{n as validateResolvedSchema};

package/dist/utils/clone.d.ts

@@ -0,0 +1 @@
+export declare const clone: <T>(value: T) => T;

package/dist/utils/clone.js

@@ -0,0 +1 @@
+const o=e=>structuredClone(e);export{o as clone};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "semanticdb-v2",
+  "version": "2.0.0-alpha.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cache/redis": {
+      "types": "./dist/cache/redis-query-cache.d.ts",
+      "import": "./dist/cache/redis-query-cache.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:rollup": "rollup -c",
+    "build": "npm run clean && npm run build:types && npm run build:rollup",
+    "typecheck": "tsc --noEmit",
+    "debug": "vite-node debug/debug.ts",
+    "test": "vitest run --coverage",
+    "lint": "eslint .",
+    "check": "npm run lint && npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "@clickhouse/client": "^1.11.2",
+    "dayjs": "^1.11.21",
+    "mysql2": "^3.14.4",
+    "oracledb": "^6.10.0",
+    "pg": "^8.23.0",
+    "redis": "^5.10.0",
+    "snowflake-sdk": "^2.4.3"
+  },
+  "peerDependencies": {
+    "semanticdb-core": "^1.1.57"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.32.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@rollup/rollup-darwin-arm64": "^4.62.4",
+    "@types/node": "^22.17.0",
+    "@types/oracledb": "^6.10.4",
+    "@types/pg": "^8.21.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^17.4.2",
+    "esbuild": "^0.28.1",
+    "eslint": "^9.32.0",
+    "rollup": "^4.62.4",
+    "semanticdb-core": "^1.1.57",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.38.0",
+    "vitest": "^3.2.4"
+  }
+}