@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/components/aql/QueryBuilder/mapper.d.ts

@@ -0,0 +1,11 @@
+import { type FunctionPool, type QlPredicate, type QlPredicateError } from "../../../../vendor/aql/index.js";
+import type { AdaptableApi } from '../../../Api/AdaptableApi';
+import type { AdaptableExpressionFunction as ExpressionFunction } from '../../../aql/types';
+import type { AdaptableModule } from '../../../types';
+export interface QueryBuilderMapper {
+    functionPool: FunctionPool<ExpressionFunction>;
+    parse: (expression: string) => QlPredicate | QlPredicateError | null;
+    print: (predicate: QlPredicate | null | undefined) => string;
+}
+/** Bind Adaptable's resolved per-module function pool to AQL's mapper. */
+export declare const buildQueryBuilderMapper: (api: AdaptableApi, module: AdaptableModule) => QueryBuilderMapper;

package/src/components/aql/QueryBuilder/mapper.js

@@ -0,0 +1,17 @@
+import { mapExpressionToQlPredicate, mapQlPredicateToExpression, } from "../../../../vendor/aql/index.js";
+const getCustomPoolNames = (pool, systemPool) => (pool ? Object.keys(pool).filter((name) => !(name in systemPool)) : []);
+export const buildQueryBuilderMapper = (api, module) => {
+    const queryLanguageService = api.internalApi.getQueryLanguageService();
+    const pool = queryLanguageService.getModuleExpressionFunctionsMap(module);
+    const scalarFunctions = pool.scalarFunctions ?? {};
+    const options = {
+        scalarFunctions,
+        customAggregatedNames: queryLanguageService.getAggregationCatalogue(module).customNames(),
+        isBooleanColumn: (columnId) => api.columnApi.getColumnWithColumnId(columnId)?.dataType === 'boolean',
+    };
+    return {
+        functionPool: { scalarFunctions },
+        parse: (expression) => mapExpressionToQlPredicate(expression, options),
+        print: (predicate) => mapQlPredicateToExpression(predicate),
+    };
+};

package/src/components/aql/QueryBuilder/qlGroupUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Adaptable-backed RHS option providers for QueryBuilder editors.
+ *
+ * Generic predicate builders, draft completeness, and normalization now live
+ * in `@adaptabletools/aql`; this module contains only host API lookups.
+ */
+import type { AdaptableApi } from '../../../Api/AdaptableApi';
+import type { AdaptableColumnDataType } from '../../../types';
+export interface QueryBuilderRhsOption {
+    value: string;
+    label: string;
+    type: AdaptableColumnDataType;
+}
+export declare const getQueryBuilderColumnOptions: (api: AdaptableApi, type?: AdaptableColumnDataType) => QueryBuilderRhsOption[];
+export declare const getQueryBuilderFieldOptions: (api: AdaptableApi, type?: AdaptableColumnDataType) => QueryBuilderRhsOption[];

package/src/components/aql/QueryBuilder/qlGroupUtils.js

@@ -0,0 +1,24 @@
+const QUERYABLE_DATA_TYPES = [
+    'text',
+    'number',
+    'boolean',
+    'date',
+];
+const matchesDataType = (requested, dataType) => requested
+    ? dataType === requested
+    : QUERYABLE_DATA_TYPES.includes(dataType);
+export const getQueryBuilderColumnOptions = (api, type) => api.columnApi.internalApi
+    .getQueryableColumnsForUIEditor()
+    .filter((column) => matchesDataType(type, column.dataType))
+    .map((column) => ({
+    value: column.columnId,
+    label: column.friendlyName ?? column.columnId,
+    type: column.dataType,
+}));
+export const getQueryBuilderFieldOptions = (api, type) => (api.expressionApi.internalApi.getAvailableFields() ?? [])
+    .filter((field) => matchesDataType(type, field.dataType))
+    .map((field) => ({
+    value: field.name,
+    label: field.label ?? field.name,
+    type: field.dataType,
+}));

package/src/components/aql/QueryBuilder/utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Adaptable host glue for the host-agnostic QueryBuilder language mechanics
+ * exported by `@adaptabletools/aql`.
+ *
+ * Operator resolution, draft factories/completeness, primitive slots, and
+ * editor-tree transforms live in aql. This module only maps Adaptable column
+ * types/scopes/API services into that surface and performs host UI validation.
+ */
+import { type ExpressionTypeIssue, type FunctionPool, type QlArg, type QlPredicate, type QlPredicateError, type ResolvedOperatorSlot } from "../../../../vendor/aql/index.js";
+import type { AdaptableApi } from '../../../Api/AdaptableApi';
+import type { AdaptableExpressionFunction as ExpressionFunction } from '../../../aql/types';
+import type { AdaptableColumnDataType, AdaptableModule, ColumnScope } from '../../../types';
+export type QueryBuilderFunctionPool = FunctionPool<ExpressionFunction>;
+export type ResolvedQueryBuilderSlot = ResolvedOperatorSlot;
+/** Transitional system lookup for host presentation metadata. */
+export declare const getSystemFunctionDef: (operator: string | undefined) => ExpressionFunction | undefined;
+/** Adaptable-column-type adapter around aql's host-neutral resolver. */
+export declare const getOperatorsForSubjectType: (dataType: AdaptableColumnDataType | undefined, names: string[], pool: QueryBuilderFunctionPool) => string[];
+/** Adaptable-column-type adapter with mixed-scope intersection semantics. */
+export declare const getOperatorsForSubjectTypes: (dataTypes: AdaptableColumnDataType[] | undefined, names: string[], pool: QueryBuilderFunctionPool) => string[];
+export declare const resolveScopeDataTypes: (scope: ColumnScope | undefined, api: AdaptableApi) => AdaptableColumnDataType[];
+export declare const resolveScopeDataType: (scope: ColumnScope | undefined, api: AdaptableApi) => AdaptableColumnDataType | undefined;
+export interface QueryBuilderScopeMeta {
+    scope: ColumnScope;
+    description: string;
+    resolvedDataType: AdaptableColumnDataType | undefined;
+    resolvedDataTypes: AdaptableColumnDataType[];
+    representativeColumnId: string | undefined;
+}
+export declare const buildQueryBuilderScopeMeta: (scope: ColumnScope | undefined, api: AdaptableApi) => QueryBuilderScopeMeta | undefined;
+export declare const getUnsupportedReasonForNode: (node: QlPredicate | QlPredicateError | null, context: {
+    supportedFields: {
+        value: string;
+    }[];
+    columnScope?: ColumnScope;
+}) => string | null;
+export type QueryBuilderCannotDisplayReason = 'advanced' | 'scalar' | 'type-mismatch' | 'invalid'
+/** A live (observable) brace call — valid boolean, but the builder has no editor for it. */
+ | 'observable-call' | null;
+export type QueryBuilderExpressionValidity = 'boolean' | 'scalar' | 'invalid';
+/**
+ * Why the Query Builder shows the cannot-display shell instead of the editor
+ * tree. A valid boolean expression the mapper cannot represent (e.g.
+ * statement-level WHERE, some advanced shapes) is **advanced**, not invalid.
+ * Bare boolean columns (`[isLive]`) are lowered to `[isLive] = TRUE` and
+ * display normally.
+ */
+export declare const getQueryBuilderCannotDisplayReason: (args: {
+    root: QlPredicate | QlPredicateError;
+    outputExpressionValidity: QueryBuilderExpressionValidity;
+    unsupportedReason: string | null;
+    seedTypeIssues: ExpressionTypeIssue[];
+}) => QueryBuilderCannotDisplayReason;
+/**
+ * Validity classification for the Query Builder's boolean domain. Aggregated
+ * booleans (`SUM{…} > 100`) count as boolean so the builder shows them as
+ * advanced (open in the Expression Editor) rather than invalid.
+ *
+ * - `'boolean'` — valid under any of the boolean-producing kinds
+ * - `'scalar'`  — a valid value expression, just not a boolean one
+ * - `'invalid'` — fails every validation
+ */
+export declare const getBooleanExpressionValidity: (api: AdaptableApi, module: AdaptableModule, expression: string) => "boolean" | "scalar" | "invalid";
+/**
+ * Static type + AdapTable column-catalog issues for an expression.
+ * Parse failures return `[]` — those are handled by Query Builder's existing
+ * invalid/advanced shell, not the type-mismatch path.
+ *
+ * Missing-column checks are host-side (AdapTable grid catalog), not AQL core.
+ */
+export declare const getExpressionTypeIssues: (api: AdaptableApi, module: AdaptableModule, expression: string | undefined | null) => ExpressionTypeIssue[];
+export declare const resolveLefthandColumnIdForValueEditors: (subject: QlArg | undefined, scopeMeta: QueryBuilderScopeMeta | undefined) => string | undefined;
+export declare const resolveSubjectDataType: (subject: QlArg | undefined, api: AdaptableApi, scopeMeta: QueryBuilderScopeMeta | undefined) => AdaptableColumnDataType | undefined;
+export declare const resolveSubjectDataTypes: (subject: QlArg | undefined, api: AdaptableApi, scopeMeta: QueryBuilderScopeMeta | undefined) => AdaptableColumnDataType[] | undefined;

package/src/components/aql/QueryBuilder/utils.js

@@ -0,0 +1,200 @@
+import { getOperatorsForSubjectType as getAqlOperatorsForSubjectType, getOperatorsForSubjectTypes as getAqlOperatorsForSubjectTypes, isQlAggCall, isQlArgPredicate, isQlColRef, isQlFieldRef, isQlFnCall, isQlGroup, isQlPredicateError, isQlScopeRef, mapDataTypeToStaticType, operatorHasSubject, parse, OBSERVABLE_CALL_UNSUPPORTED_REASON, validateExpressionTypes, } from "../../../../vendor/aql/index.js";
+import { getMissingColumnIssues } from '../../../aql/getMissingColumnIssues';
+import { isScopeColumnIds, isScopeDataTypes, } from '../../../AdaptableState/Common/ColumnScope';
+import { mapColumnDataTypeToExpressionFunctionType } from '../../../aql/adaptableQlUtils';
+import { systemScalarExpressionFunctions as scalarExpressionFunctions } from '../../../aql/systemExpressionFunctions';
+export const getSystemFunctionDef = (operator) => operator
+    ? scalarExpressionFunctions[operator]
+    : undefined;
+export const getOperatorsForSubjectType = (dataType, names, pool) => getAqlOperatorsForSubjectType(dataType
+    ? mapColumnDataTypeToExpressionFunctionType(dataType)
+    : undefined, names, pool);
+export const getOperatorsForSubjectTypes = (dataTypes, names, pool) => getAqlOperatorsForSubjectTypes(dataTypes?.map(mapColumnDataTypeToExpressionFunctionType), names, pool);
+export const resolveScopeDataTypes = (scope, api) => {
+    if (!scope)
+        return [];
+    if (isScopeDataTypes(scope)) {
+        const seen = new Set();
+        const result = [];
+        for (const type of scope.DataTypes ?? []) {
+            const dataType = type;
+            if (!seen.has(dataType)) {
+                seen.add(dataType);
+                result.push(dataType);
+            }
+        }
+        return result;
+    }
+    const result = [];
+    const seen = new Set();
+    for (const column of api.columnScopeApi.getColumnsInScope(scope)) {
+        if (column.dataType && !seen.has(column.dataType)) {
+            seen.add(column.dataType);
+            result.push(column.dataType);
+        }
+    }
+    return result;
+};
+export const resolveScopeDataType = (scope, api) => {
+    const types = resolveScopeDataTypes(scope, api);
+    return types.length === 1 ? types[0] : undefined;
+};
+const resolveScopeColumnIdForValueEditors = (scope) => isScopeColumnIds(scope) && scope.ColumnIds?.length === 1
+    ? scope.ColumnIds[0]
+    : undefined;
+export const buildQueryBuilderScopeMeta = (scope, api) => {
+    if (!scope)
+        return undefined;
+    const resolvedDataTypes = resolveScopeDataTypes(scope, api);
+    return {
+        scope,
+        description: api.columnScopeApi.getScopeDescription(scope),
+        resolvedDataType: resolvedDataTypes.length === 1 ? resolvedDataTypes[0] : undefined,
+        resolvedDataTypes,
+        representativeColumnId: resolveScopeColumnIdForValueEditors(scope),
+    };
+};
+export const getUnsupportedReasonForNode = (node, context) => {
+    if (!node || isQlPredicateError(node))
+        return null;
+    if (isQlGroup(node)) {
+        for (const child of node.children) {
+            const reason = getUnsupportedReasonForNode(child, context);
+            if (reason)
+                return reason;
+        }
+        return null;
+    }
+    const fn = getSystemFunctionDef(node.operator);
+    if (operatorHasSubject(fn) || (!fn && node.args.length > 0)) {
+        const subject = node.args[0];
+        if (subject != null &&
+            !isQlColRef(subject) &&
+            !isQlFieldRef(subject) &&
+            !isQlScopeRef(subject)) {
+            return 'Expression uses a lefthand subject that Query Builder cannot display.';
+        }
+    }
+    for (const arg of node.args) {
+        const reason = getUnsupportedReasonForArg(arg, context);
+        if (reason)
+            return reason;
+    }
+    return null;
+};
+export const getQueryBuilderCannotDisplayReason = (args) => {
+    if (args.unsupportedReason) {
+        return 'advanced';
+    }
+    if (isQlPredicateError(args.root)) {
+        const msg = args.root.errorMessage ?? '';
+        if (msg.startsWith(`${OBSERVABLE_CALL_UNSUPPORTED_REASON}:`)) {
+            return 'observable-call';
+        }
+        if (/not supported in the Query Builder/i.test(msg) || /multi-statement/i.test(msg)) {
+            return 'advanced';
+        }
+        if (args.outputExpressionValidity === 'scalar') {
+            return 'scalar';
+        }
+        if (args.outputExpressionValidity === 'boolean') {
+            return 'advanced';
+        }
+        return 'invalid';
+    }
+    if (args.seedTypeIssues.length > 0) {
+        return 'type-mismatch';
+    }
+    return null;
+};
+export const getBooleanExpressionValidity = (api, module, expression) => {
+    const trimmed = (expression ?? '').trim();
+    if (!trimmed) {
+        return 'boolean';
+    }
+    const service = api.internalApi.getQueryLanguageService();
+    if (service.validateBoolean(trimmed, module, { force: true }).isValid) {
+        return 'boolean';
+    }
+    if (service.validateAggregatedBoolean(trimmed, module).isValid) {
+        return 'boolean';
+    }
+    if (api.expressionApi.isValidValueExpression(trimmed, module)) {
+        return 'scalar';
+    }
+    return 'invalid';
+};
+export const getExpressionTypeIssues = (api, module, expression) => {
+    const trimmed = (expression ?? '').trim();
+    if (!trimmed) {
+        return [];
+    }
+    let ast;
+    try {
+        ({ ast } = parse(trimmed));
+    }
+    catch {
+        return [];
+    }
+    const scalarFunctions = api.internalApi
+        .getQueryLanguageService()
+        .getModuleExpressionFunctionsMap(module).scalarFunctions ?? {};
+    const typeIssues = validateExpressionTypes(ast, scalarFunctions, {
+        getColumnType: (columnId) => mapDataTypeToStaticType(api.columnApi.getColumnDataTypeForColumnId(columnId)),
+    }).issues;
+    const missingColumnIssues = getMissingColumnIssues(ast, (columnId) => api.columnApi.isColumnInGrid(columnId));
+    return [...missingColumnIssues, ...typeIssues];
+};
+const getUnsupportedReasonForArg = (arg, context) => {
+    if (isQlScopeRef(arg)) {
+        return context.columnScope
+            ? null
+            : '$SCOPE is not available in this editor (the parent object has no Scope).';
+    }
+    if (isQlFieldRef(arg)) {
+        return context.supportedFields.some((field) => field?.value === arg.fieldName)
+            ? null
+            : `Expression uses an unregistered field: "${arg.fieldName}"`;
+    }
+    if (isQlAggCall(arg)) {
+        return 'Expression uses an Aggregation, which Query Builder cannot display.';
+    }
+    if (isQlArgPredicate(arg)) {
+        return getUnsupportedReasonForNode(arg, context);
+    }
+    if (isQlFnCall(arg)) {
+        for (const inner of arg.args) {
+            const reason = getUnsupportedReasonForArg(inner, context);
+            if (reason)
+                return reason;
+        }
+    }
+    return null;
+};
+export const resolveLefthandColumnIdForValueEditors = (subject, scopeMeta) => {
+    if (isQlColRef(subject))
+        return subject.columnId;
+    if (isQlScopeRef(subject))
+        return scopeMeta?.representativeColumnId;
+    return undefined;
+};
+export const resolveSubjectDataType = (subject, api, scopeMeta) => {
+    const types = resolveSubjectDataTypes(subject, api, scopeMeta);
+    return types?.length === 1 ? types[0] : undefined;
+};
+export const resolveSubjectDataTypes = (subject, api, scopeMeta) => {
+    if (!subject)
+        return undefined;
+    if (isQlColRef(subject)) {
+        const dataType = api.columnApi.getColumnDataTypeForColumnId(subject.columnId);
+        return dataType ? [dataType] : undefined;
+    }
+    if (isQlFieldRef(subject)) {
+        const dataType = api.expressionApi.internalApi.getFieldType(subject.fieldName);
+        return dataType ? [dataType] : undefined;
+    }
+    if (isQlScopeRef(subject)) {
+        return scopeMeta?.resolvedDataTypes ?? [];
+    }
+    return undefined;
+};

package/src/components/icons/add-circle.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/add-circle.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z" }) }));

package/src/components/icons/column-info.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+/**
+ * Pair with grid-info: vertical columns + the same info badge
+ * (grid-info uses horizontal lines + info).
+ */
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/column-info.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsxs(DefaultIcon, { ...props, viewBox: "0 -960 960 960", children: [_jsx("path", { d: "M160-200h80v-560h-80v560Zm160 0h80v-560h-80v560Zm160 0h80v-288q-17-8-34.5-17T492-527v327Z" }), _jsx("path", { d: "M624-480.774Q544-432 488-488.226t-56-136Q432-704 488.226-760t136-56Q704-816 760-759.774t56 136Q816-544 759.774-488t-136 56Zm0-186h48v-96h-48v96Zm24-144q9.6 0 16.8-7.2 7.2-7.2 7.2-16.8 0-9.6-7.2-16.8-7.2-7.2-16.8-7.2-9.6 0-16.8 7.2-7.2 7.2-7.2 16.8 0 9.6 7.2 16.8 7.2 7.2 16.8 7.2Z" })] }));

package/src/components/icons/in.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+/** List membership — three rows with a check (In filter). */
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/in.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M14 10H2v2h12v-2zm0-4H2v2h12V6zM2 16h8v-2H2v2zm19.5-4.5L23 13l-7 7-4.5-4.5L13 14l3.5 3.5 6-6z" }) }));

package/src/components/icons/index.js

@@ -52,6 +52,8 @@ import ColumnAdd from './column-add';
 import CellValidation from './cell-validation';
 import ColumnFilter from './column-filter';
 import ColumnOutline from './column-outline';
+import ColumnInfo from './column-info';
+import CustomSort from './custom-sort';
 import SystemStatus from './system-status';
 import DataSet from './data-set';
 import DataObject from './data-object';
@@ -65,6 +67,7 @@ import comment from './comment';
 import Layout from './layout';
 import StateManagement from './state-management';
 import ToolPanel from './tool-panel';
+import ToolPanelLayout from './tool-panel-layout';
 import PercentBar from './percent-bar';
 import Sparkline from './spark-line';
 import BulletChart from './bullet-chart';
@@ -74,11 +77,13 @@ import Star from './star';
 import Resume from './resume';
 import PieChart from './pie-chart';
 import PlusMinus from './plus-minus';
+import AddCircle from './add-circle';
 import QuickSearch from './quick-search';
 import Reminder from './reminder';
 import Schedule from './schedule';
 import Inspector from './inspector';
 import Shortcut from './shortcut';
+import Link from './link';
 import UpdatedRow from './updated-row';
 import logout from './logout';
 import Theme from './theme';
@@ -128,6 +133,9 @@ import Blanks from './blanks';
 import NonBlanks from './non-blanks';
 import Contains from './contains';
 import NotContains from './not-contains';
+import In from './in';
+import NotIn from './not-in';
+import SameDay from './same-day';
 import Regex from './regex';
 import TrackChanges from './track-changes';
 import Menu from './menu';
@@ -205,6 +213,7 @@ export const allIcons = {
     chat: Chat,
     'filter-list': ColumnFilter,
     'column-outline': ColumnOutline,
+    'column-info': ColumnInfo,
     'grid-filter': GridFilter,
     'grid-info': GridInfo,
     filter: Filter,
@@ -219,12 +228,15 @@ export const allIcons = {
     resume: Resume,
     csv: CSV,
     'pie-chart': PieChart,
-    'add-circle': PlusMinus,
+    'add-circle': AddCircle,
+    'plus-minus': PlusMinus,
     reminder: Reminder,
     schedule: Schedule,
-    link: Shortcut,
+    link: Link,
+    shortcut: Shortcut,
     assignment: StateManagement,
     clipboard: ToolPanel,
+    'tool-panel': ToolPanelLayout,
     'traffic-lights': SystemStatus,
     add: AddRow,
     downloaded: UpdatedRow,
@@ -265,6 +277,7 @@ export const allIcons = {
     home: Home,
     'sort-asc': SortAsc,
     'sort-desc': SortDesc,
+    'custom-sort': CustomSort,
     logout: logout,
     'import-export': ImportExport,
     import: Import,
@@ -307,6 +320,9 @@ export const allIcons = {
     'filled-circle': NonBlanks,
     'not-contains': NotContains,
     contains: Contains,
+    in: In,
+    'not-in': NotIn,
+    'same-day': SameDay,
     regex: Regex,
     target: TrackChanges,
     menu: Menu,

package/src/components/icons/link.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/link.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z" }) }));

package/src/components/icons/not-in.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+/** List exclusion — three rows with a clear/X (Not In filter). */
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/not-in.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M14 10H2v2h12v-2zm0-4H2v2h12V6zM2 16h8v-2H2v2zm19.54-1.12l-1.42 1.41L18 14.41l-2.12 2.12-1.41-1.41L16.59 13l-2.12-2.12 1.41-1.41L18 11.59l2.12-2.12 1.41 1.41L19.41 13l2.13 2.12z" }) }));

package/src/components/icons/plus-minus.d.ts

@@ -1,3 +1,4 @@
 import * as React from 'react';
+/** Plus and minus — used for the Plus Minus module (increment / decrement nudges). */
 declare const _default: (props: any) => React.JSX.Element;
 export default _default;

package/src/components/icons/plus-minus.js

@@ -1,3 +1,3 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import DefaultIcon from './DefaultIcon';
-export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z" }) }));
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M4 11h7v2H4zm9-3h2v3h3v2h-3v3h-2v-3h-3v-2h3z" }) }));

package/src/components/icons/same-day.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+/**
+ * Two matching day tiles — “same calendar day” without a full calendar
+ * chrome (so it doesn’t clash with the date-picker calendar affordance)
+ * and without the Equals bars.
+ */
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/same-day.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M3 5h8v14H3V5zm2 2v2h4V7H5zm0 4v2h4v-2H5zm0 4v2h3v-2H5zm10-10h8v14h-8V5zm2 2v2h4V7h-4zm0 4v2h4v-2h-4zm0 4v2h3v-2h-3z" }) }));

package/src/components/icons/shortcut.d.ts

@@ -1,3 +1,4 @@
 import * as React from 'react';
+/** Keyboard — used for the Shortcut module (keystroke-driven edits). */
 declare const _default: (props: any) => React.JSX.Element;
 export default _default;

package/src/components/icons/shortcut.js

@@ -1,3 +1,3 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import DefaultIcon from './DefaultIcon';
-export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z" }) }));
+export default (props) => (_jsx(DefaultIcon, { ...props, children: _jsx("path", { d: "M20 5H4c-1.1 0-1.99.9-1.99 2L2 17c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-9 3h2v2h-2V8zm0 3h2v2h-2v-2zM8 8h2v2H8V8zm0 3h2v2H8v-2zm-1 2H5v-2h2v2zm0-3H5V8h2v2zm9 7H8v-2h8v2zm0-4h-2v-2h2v2zm0-3h-2V8h2v2zm3 3h-2v-2h2v2zm0-3h-2V8h2v2z" }) }));

package/src/components/icons/tool-panel-layout.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+/**
+ * Pair with statusbar: same window frame, vertical strip on the right
+ * (statusbar has a horizontal strip along the bottom).
+ */
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;

package/src/components/icons/tool-panel-layout.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import DefaultIcon from './DefaultIcon';
+export default (props) => (_jsxs(DefaultIcon, { ...props, children: [_jsx("path", { d: "M0 0h24v24H0V0z", fill: "none" }), _jsx("path", { d: "M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h18v14zM16 5h3v14h-3z" })] }));

package/src/components/twUtils.d.ts

@@ -1,10 +1 @@
-export declare const targetOwn: {
-    focusOutline: string;
-    focusWithinOutline: string;
-};
-export declare const targetPeer: {
-    focusVisibleOutline: string;
-};
-export declare const targetChildren: {
-    focusWithinOutline: string;
-};
+export { targetOwn, targetPeer, targetChildren } from "../../vendor/components/twUtils";

package/src/components/twUtils.js

@@ -1,10 +1 @@
-export const targetOwn = {
-    focusOutline: 'twa:outline-none twa:focus-visible:border-ring twa:focus-visible:ring-3 twa:focus-visible:ring-ring/50',
-    focusWithinOutline: 'twa:outline-none twa:focus-within:border-ring twa:focus-within:ring-3 twa:focus-within:ring-ring/50',
-};
-export const targetPeer = {
-    focusVisibleOutline: 'twa:peer-focus-visible:border-ring twa:peer-focus-visible:ring-3 twa:peer-focus-visible:ring-ring/50',
-};
-export const targetChildren = {
-    focusWithinOutline: 'twa:*:outline-none twa:*:focus-within:border-ring twa:*:focus-within:ring-3 twa:*:focus-within:ring-ring/50',
-};
+export { targetOwn, targetPeer, targetChildren } from "../../vendor/components/twUtils";

package/src/components/ui/calendar.d.ts

@@ -1,7 +1 @@
-import * as React from 'react';
-import { DayPicker } from 'react-day-picker';
-import { Button } from './button';
-declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
-    buttonVariant?: React.ComponentProps<typeof Button>['variant'];
-}): React.JSX.Element;
-export { Calendar };
+export { Calendar } from "../../../vendor/components/ui/calendar";