hunk
dict | file
stringlengths 0
11.8M
| file_path
stringlengths 2
234
| label
int64 0
1
| commit_url
stringlengths 74
103
| dependency_score
listlengths 5
5
|
|---|---|---|---|---|---|
{
"id": 1,
"code_window": [
"import { CompletionItemGroup, SearchFunctionType, Token, TypeaheadInput, TypeaheadOutput } from '@grafana/ui';\n",
"import { getTemplateSrv } from 'app/features/templating/template_srv';\n",
"\n",
"import { CloudWatchDatasource } from '../../datasource';\n",
"import { CloudWatchQuery, LogGroup, TSDBResponse } from '../../types';\n",
"import { interpolateStringArrayUsingSingleOrMultiValuedVariable } from '../../utils/templateVariableUtils';\n",
"\n",
"import syntax, {\n",
" AGGREGATION_FUNCTIONS_STATS,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchQuery, LogGroup } from '../../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 8
} | package conditions
import (
"context"
"testing"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/infra/db/dbtest"
"github.com/grafana/grafana/pkg/infra/localcache"
"github.com/grafana/grafana/pkg/services/alerting"
"github.com/grafana/grafana/pkg/services/datasources"
fd "github.com/grafana/grafana/pkg/services/datasources/fakes"
"github.com/grafana/grafana/pkg/services/validations"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/tsdb/intervalv2"
"github.com/grafana/grafana/pkg/tsdb/legacydata"
)
func TestQueryInterval(t *testing.T) {
t.Run("When evaluating query condition, regarding the interval value", func(t *testing.T) {
t.Run("Can handle interval-calculation with no panel-min-interval and no datasource-min-interval", func(t *testing.T) {
// no panel-min-interval in the queryModel
queryModel := `{"target": "aliasByNode(statsd.fakesite.counters.session_start.mobile.count, 4)"}`
// no datasource-min-interval
var dataSourceJson *simplejson.Json = nil
timeRange := "5m"
verifier := func(query legacydata.DataSubQuery) {
// 5minutes timerange = 300000milliseconds; default-resolution is 1500pixels,
// so we should have 300000/1500 = 200milliseconds here
require.Equal(t, int64(200), query.IntervalMS)
require.Equal(t, intervalv2.DefaultRes, query.MaxDataPoints)
}
applyScenario(t, timeRange, dataSourceJson, queryModel, verifier)
})
t.Run("Can handle interval-calculation with panel-min-interval and no datasource-min-interval", func(t *testing.T) {
// panel-min-interval in the queryModel
queryModel := `{"interval":"123s", "target": "aliasByNode(statsd.fakesite.counters.session_start.mobile.count, 4)"}`
// no datasource-min-interval
var dataSourceJson *simplejson.Json = nil
timeRange := "5m"
verifier := func(query legacydata.DataSubQuery) {
require.Equal(t, int64(123000), query.IntervalMS)
require.Equal(t, intervalv2.DefaultRes, query.MaxDataPoints)
}
applyScenario(t, timeRange, dataSourceJson, queryModel, verifier)
})
t.Run("Can handle interval-calculation with no panel-min-interval and datasource-min-interval", func(t *testing.T) {
// no panel-min-interval in the queryModel
queryModel := `{"target": "aliasByNode(statsd.fakesite.counters.session_start.mobile.count, 4)"}`
// min-interval in datasource-json
dataSourceJson, err := simplejson.NewJson([]byte(`{
"timeInterval": "71s"
}`))
require.Nil(t, err)
timeRange := "5m"
verifier := func(query legacydata.DataSubQuery) {
require.Equal(t, int64(71000), query.IntervalMS)
require.Equal(t, intervalv2.DefaultRes, query.MaxDataPoints)
}
applyScenario(t, timeRange, dataSourceJson, queryModel, verifier)
})
t.Run("Can handle interval-calculation with both panel-min-interval and datasource-min-interval", func(t *testing.T) {
// panel-min-interval in the queryModel
queryModel := `{"interval":"19s", "target": "aliasByNode(statsd.fakesite.counters.session_start.mobile.count, 4)"}`
// min-interval in datasource-json
dataSourceJson, err := simplejson.NewJson([]byte(`{
"timeInterval": "71s"
}`))
require.Nil(t, err)
timeRange := "5m"
verifier := func(query legacydata.DataSubQuery) {
// when both panel-min-interval and datasource-min-interval exists,
// panel-min-interval is used
require.Equal(t, int64(19000), query.IntervalMS)
require.Equal(t, intervalv2.DefaultRes, query.MaxDataPoints)
}
applyScenario(t, timeRange, dataSourceJson, queryModel, verifier)
})
t.Run("Can handle no min-interval, and very small time-ranges, where the default-min-interval=1ms applies", func(t *testing.T) {
// no panel-min-interval in the queryModel
queryModel := `{"target": "aliasByNode(statsd.fakesite.counters.session_start.mobile.count, 4)"}`
// no datasource-min-interval
var dataSourceJson *simplejson.Json = nil
timeRange := "1s"
verifier := func(query legacydata.DataSubQuery) {
// no min-interval exists, the default-min-interval will be used,
// and for such a short time-range this will cause the value to be 1millisecond.
require.Equal(t, int64(1), query.IntervalMS)
require.Equal(t, intervalv2.DefaultRes, query.MaxDataPoints)
}
applyScenario(t, timeRange, dataSourceJson, queryModel, verifier)
})
})
}
type queryIntervalTestContext struct {
result *alerting.EvalContext
condition *QueryCondition
}
type queryIntervalVerifier func(query legacydata.DataSubQuery)
type fakeIntervalTestReqHandler struct {
//nolint: staticcheck // legacydata.DataResponse deprecated
response legacydata.DataResponse
verifier queryIntervalVerifier
}
//nolint:staticcheck // legacydata.DataResponse deprecated
func (rh fakeIntervalTestReqHandler) HandleRequest(ctx context.Context, dsInfo *datasources.DataSource, query legacydata.DataQuery) (
legacydata.DataResponse, error) {
q := query.Queries[0]
rh.verifier(q)
return rh.response, nil
}
//nolint:staticcheck // legacydata.DataResponse deprecated
func applyScenario(t *testing.T, timeRange string, dataSourceJsonData *simplejson.Json, queryModel string, verifier func(query legacydata.DataSubQuery)) {
t.Run("desc", func(t *testing.T) {
db := dbtest.NewFakeDB()
store := alerting.ProvideAlertStore(db, localcache.ProvideService(), &setting.Cfg{}, nil)
ctx := &queryIntervalTestContext{}
ctx.result = &alerting.EvalContext{
Ctx: context.Background(),
Rule: &alerting.Rule{},
RequestValidator: &validations.OSSPluginRequestValidator{},
Store: store,
DatasourceService: &fd.FakeDataSourceService{
DataSources: []*datasources.DataSource{
{ID: 1, Type: datasources.DS_GRAPHITE, JsonData: dataSourceJsonData},
},
},
}
jsonModel, err := simplejson.NewJson([]byte(`{
"type": "query",
"query": {
"params": ["A", "` + timeRange + `", "now"],
"datasourceId": 1,
"model": ` + queryModel + `
},
"reducer":{"type": "avg"},
"evaluator":{"type": "gt", "params": [100]}
}`))
require.Nil(t, err)
condition, err := newQueryCondition(jsonModel, 0)
require.Nil(t, err)
ctx.condition = condition
qr := legacydata.DataQueryResult{}
reqHandler := fakeIntervalTestReqHandler{
response: legacydata.DataResponse{
Results: map[string]legacydata.DataQueryResult{
"A": qr,
},
},
verifier: verifier,
}
_, err = condition.Eval(ctx.result, reqHandler)
require.Nil(t, err)
})
}
| pkg/services/alerting/conditions/query_interval_test.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017272036348003894,
0.00016921915812417865,
0.0001601176045369357,
0.00016958318883553147,
0.000003311214413770358
]
|
{
"id": 1,
"code_window": [
"import { CompletionItemGroup, SearchFunctionType, Token, TypeaheadInput, TypeaheadOutput } from '@grafana/ui';\n",
"import { getTemplateSrv } from 'app/features/templating/template_srv';\n",
"\n",
"import { CloudWatchDatasource } from '../../datasource';\n",
"import { CloudWatchQuery, LogGroup, TSDBResponse } from '../../types';\n",
"import { interpolateStringArrayUsingSingleOrMultiValuedVariable } from '../../utils/templateVariableUtils';\n",
"\n",
"import syntax, {\n",
" AGGREGATION_FUNCTIONS_STATS,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchQuery, LogGroup } from '../../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 8
} | package dashverimpl
import (
"context"
"strings"
"github.com/grafana/grafana/pkg/infra/db"
dashver "github.com/grafana/grafana/pkg/services/dashboardversion"
"github.com/grafana/grafana/pkg/services/sqlstore/migrator"
)
type sqlStore struct {
db db.DB
dialect migrator.Dialect
}
func (ss *sqlStore) Get(ctx context.Context, query *dashver.GetDashboardVersionQuery) (*dashver.DashboardVersion, error) {
var version dashver.DashboardVersion
err := ss.db.WithDbSession(ctx, func(sess *db.Session) error {
has, err := sess.Where("dashboard_version.dashboard_id=? AND dashboard_version.version=? AND dashboard.org_id=?", query.DashboardID, query.Version, query.OrgID).
Join("LEFT", "dashboard", `dashboard.id = dashboard_version.dashboard_id`).
Get(&version)
if err != nil {
return err
}
if !has {
return dashver.ErrDashboardVersionNotFound
}
return nil
})
if err != nil {
return nil, err
}
return &version, nil
}
func (ss *sqlStore) GetBatch(ctx context.Context, cmd *dashver.DeleteExpiredVersionsCommand, perBatch int, versionsToKeep int) ([]interface{}, error) {
var versionIds []interface{}
err := ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
versionIdsToDeleteQuery := `SELECT id
FROM dashboard_version, (
SELECT dashboard_id, count(version) as count, min(version) as min
FROM dashboard_version
GROUP BY dashboard_id
) AS vtd
WHERE dashboard_version.dashboard_id=vtd.dashboard_id
AND version < vtd.min + vtd.count - ?
LIMIT ?`
err := sess.SQL(versionIdsToDeleteQuery, versionsToKeep, perBatch).Find(&versionIds)
return err
})
return versionIds, err
}
func (ss *sqlStore) DeleteBatch(ctx context.Context, cmd *dashver.DeleteExpiredVersionsCommand, versionIdsToDelete []interface{}) (int64, error) {
var deleted int64
err := ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
deleteExpiredSQL := `DELETE FROM dashboard_version WHERE id IN (?` + strings.Repeat(",?", len(versionIdsToDelete)-1) + `)`
sqlOrArgs := append([]interface{}{deleteExpiredSQL}, versionIdsToDelete...)
expiredResponse, err := sess.Exec(sqlOrArgs...)
if err != nil {
return err
}
deleted, err = expiredResponse.RowsAffected()
return err
})
return deleted, err
}
func (ss *sqlStore) List(ctx context.Context, query *dashver.ListDashboardVersionsQuery) ([]*dashver.DashboardVersion, error) {
var dashboardVersion []*dashver.DashboardVersion
err := ss.db.WithDbSession(ctx, func(sess *db.Session) error {
err := sess.Table("dashboard_version").
Select(`dashboard_version.id,
dashboard_version.dashboard_id,
dashboard_version.parent_version,
dashboard_version.restored_from,
dashboard_version.version,
dashboard_version.created,
dashboard_version.created_by,
dashboard_version.message,
dashboard_version.data`).
Join("LEFT", "dashboard", `dashboard.id = dashboard_version.dashboard_id`).
Where("dashboard_version.dashboard_id=? AND dashboard.org_id=?", query.DashboardID, query.OrgID).
OrderBy("dashboard_version.version DESC").
Limit(query.Limit, query.Start).
Find(&dashboardVersion)
if err != nil {
return err
}
if len(dashboardVersion) < 1 {
return dashver.ErrNoVersionsForDashboardID
}
return nil
})
if err != nil {
return nil, err
}
return dashboardVersion, nil
}
| pkg/services/dashboardversion/dashverimpl/xorm_store.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017307398957200348,
0.0001686099567450583,
0.00016475300071761012,
0.00016745719767641276,
0.000002700086724871653
]
|
{
"id": 2,
"code_window": [
" getSyntax(): Grammar {\n",
" return syntax;\n",
" }\n",
"\n",
" request = (url: string, params?: any): Promise<TSDBResponse> => {\n",
" return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));\n",
" };\n",
"\n",
" start = () => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" request = (url: string, params?: any): Promise<FetchResponse<BackendDataSourceResponse>> => {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 51
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.002273893216624856,
0.0003443016903474927,
0.00016776884149294347,
0.00017295984434895217,
0.0005574849201366305
]
|
{
"id": 2,
"code_window": [
" getSyntax(): Grammar {\n",
" return syntax;\n",
" }\n",
"\n",
" request = (url: string, params?: any): Promise<TSDBResponse> => {\n",
" return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));\n",
" };\n",
"\n",
" start = () => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" request = (url: string, params?: any): Promise<FetchResponse<BackendDataSourceResponse>> => {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 51
} | import { css } from '@emotion/css';
import React, { useEffect, useState } from 'react';
import { CloudWatchDatasource } from '../../datasource';
import { useAccountOptions } from '../../hooks';
import { DescribeLogGroupsRequest } from '../../resources/types';
import { LogGroup } from '../../types';
import { isTemplateVariable } from '../../utils/templateVariableUtils';
import { LogGroupsSelector } from './LogGroupsSelector';
import { SelectedLogGroups } from './SelectedLogGroups';
type Props = {
datasource?: CloudWatchDatasource;
onChange: (logGroups: LogGroup[]) => void;
legacyLogGroupNames?: string[];
logGroups?: LogGroup[];
region: string;
maxNoOfVisibleLogGroups?: number;
onBeforeOpen?: () => void;
};
const rowGap = css`
gap: 3px;
`;
export const LogGroupsField = ({
datasource,
onChange,
legacyLogGroupNames,
logGroups,
region,
maxNoOfVisibleLogGroups,
onBeforeOpen,
}: Props) => {
const accountState = useAccountOptions(datasource?.resources, region);
const [loadingLogGroupsStarted, setLoadingLogGroupsStarted] = useState(false);
useEffect(() => {
// If log group names are stored in the query model, make a new DescribeLogGroups request for each log group to load the arn. Then update the query model.
if (datasource && !loadingLogGroupsStarted && !logGroups?.length && legacyLogGroupNames?.length) {
setLoadingLogGroupsStarted(true);
// there's no need to migrate variables, they will be taken care of in the logs query runner
const variables = legacyLogGroupNames.filter((lgn) => isTemplateVariable(datasource.resources.templateSrv, lgn));
const legacyLogGroupNameValues = legacyLogGroupNames.filter(
(lgn) => !isTemplateVariable(datasource.resources.templateSrv, lgn)
);
Promise.all(
legacyLogGroupNameValues.map((lg) =>
datasource.resources.getLogGroups({ region: region, logGroupNamePrefix: lg })
)
)
.then((results) => {
const logGroups = results.flatMap((r) =>
r.map((lg) => ({
arn: lg.value.arn,
name: lg.value.name,
accountId: lg.accountId,
}))
);
onChange([...logGroups, ...variables.map((v) => ({ name: v, arn: v }))]);
})
.catch((err) => {
console.error(err);
});
}
}, [datasource, legacyLogGroupNames, logGroups, onChange, region, loadingLogGroupsStarted]);
return (
<div className={`gf-form gf-form--grow flex-grow-1 ${rowGap}`}>
<LogGroupsSelector
fetchLogGroups={async (params: Partial<DescribeLogGroupsRequest>) =>
datasource?.resources.getLogGroups({ region: region, ...params }) ?? []
}
onChange={onChange}
accountOptions={accountState.value}
selectedLogGroups={logGroups}
onBeforeOpen={onBeforeOpen}
variables={datasource?.getVariables()}
/>
<SelectedLogGroups
selectedLogGroups={logGroups ?? []}
onChange={onChange}
maxNoOfVisibleLogGroups={maxNoOfVisibleLogGroups}
></SelectedLogGroups>
</div>
);
};
| public/app/plugins/datasource/cloudwatch/components/LogGroups/LogGroupsField.tsx | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0004666861204896122,
0.00022384049952961504,
0.00016315233369823545,
0.00017350925190839916,
0.00009179108747048303
]
|
{
"id": 2,
"code_window": [
" getSyntax(): Grammar {\n",
" return syntax;\n",
" }\n",
"\n",
" request = (url: string, params?: any): Promise<TSDBResponse> => {\n",
" return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));\n",
" };\n",
"\n",
" start = () => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" request = (url: string, params?: any): Promise<FetchResponse<BackendDataSourceResponse>> => {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 51
} | package modules
import (
"context"
"errors"
"github.com/grafana/dskit/modules"
"github.com/grafana/dskit/services"
"github.com/grafana/grafana/pkg/infra/log"
)
var _ services.ManagerListener = (*serviceListener)(nil)
type serviceListener struct {
log log.Logger
service *service
}
func newServiceListener(logger log.Logger, s *service) *serviceListener {
return &serviceListener{log: logger, service: s}
}
func (l *serviceListener) Healthy() {
l.log.Info("All modules healthy")
}
func (l *serviceListener) Stopped() {
l.log.Info("All modules stopped")
}
func (l *serviceListener) Failure(service services.Service) {
// if any service fails, stop all services
if err := l.service.Shutdown(context.Background()); err != nil {
l.log.Error("Failed to stop all modules", "err", err)
}
// log which module failed
for module, s := range l.service.ServiceMap {
if s == service {
if errors.Is(service.FailureCase(), modules.ErrStopProcess) {
l.log.Info("Received stop signal via return error", "module", module, "err", service.FailureCase())
} else {
l.log.Error("Module failed", "module", module, "err", service.FailureCase())
}
return
}
}
l.log.Error("Module failed", "module", "unknown", "err", service.FailureCase())
}
| pkg/modules/listener.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.000174395609064959,
0.0001697621337370947,
0.00016505536041222513,
0.000169009726960212,
0.000003381014948899974
]
|
{
"id": 2,
"code_window": [
" getSyntax(): Grammar {\n",
" return syntax;\n",
" }\n",
"\n",
" request = (url: string, params?: any): Promise<TSDBResponse> => {\n",
" return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));\n",
" };\n",
"\n",
" start = () => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" request = (url: string, params?: any): Promise<FetchResponse<BackendDataSourceResponse>> => {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts",
"type": "replace",
"edit_start_line_idx": 51
} | import { ArgsTable } from '@storybook/addon-docs/blocks';
import { DatePicker } from './DatePicker';
# DatePicker
A component with a calendar view for selecting a date.
### Usage
```tsx
import React, { useState } from 'react';
import { DatePicker, Button } from '@grafana/ui';
const [date, setDate] = useState<Date>(new Date());
const [open, setOpen] = useState(false);
return (
<>
<Button onClick={() => setOpen(true)}>Show Calendar</Button>
<DatePicker isOpen={open} value={date} onChange={(newDate) => setDate(newDate)} onClose={() => setOpen(false)} />
</>
);
```
### Props
<ArgsTable of={DatePicker} />
| packages/grafana-ui/src/components/DateTimePickers/DatePicker/DatePicker.mdx | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017659840523265302,
0.00017506688891444355,
0.00017326189845334738,
0.00017534034850541502,
0.0000013757801298197592
]
|
{
"id": 3,
"code_window": [
" })),\n",
" }).pipe(\n",
" map((r) => {\n",
" const frames = toDataQueryResponse({ data: r }).data;\n",
" return { data: frames };\n",
" })\n",
" );\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const frames = toDataQueryResponse(r).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchAnnotationQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 38
} | import { findLast, isEmpty } from 'lodash';
import React from 'react';
import { catchError, map, Observable, of, throwError } from 'rxjs';
import {
DataFrame,
DataQueryRequest,
DataQueryResponse,
DataSourceInstanceSettings,
dateTimeFormat,
FieldType,
rangeUtil,
ScopedVars,
TimeRange,
} from '@grafana/data';
import { toDataQueryResponse } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import { ThrottlingErrorMessage } from '../components/ThrottlingErrorMessage';
import memoizedDebounce from '../memoizedDebounce';
import { migrateMetricQuery } from '../migrations/metricQueryMigrations';
import {
CloudWatchJsonData,
CloudWatchMetricsQuery,
CloudWatchQuery,
DataQueryError,
MetricQuery,
MetricRequest,
} from '../types';
import { filterMetricsQuery } from '../utils/utils';
import { CloudWatchRequest } from './CloudWatchRequest';
const displayAlert = (datasourceName: string, region: string) =>
store.dispatch(
notifyApp(
createErrorNotification(
`CloudWatch request limit reached in ${region} for data source ${datasourceName}`,
'',
undefined,
React.createElement(ThrottlingErrorMessage, { region }, null)
)
)
);
// This class handles execution of CloudWatch metrics query data queries
export class CloudWatchMetricsQueryRunner extends CloudWatchRequest {
debouncedAlert: (datasourceName: string, region: string) => void = memoizedDebounce(
displayAlert,
AppNotificationTimeout.Error
);
constructor(instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
super(instanceSettings, templateSrv);
}
handleMetricQueries = (
metricQueries: CloudWatchMetricsQuery[],
options: DataQueryRequest<CloudWatchQuery>
): Observable<DataQueryResponse> => {
const timezoneUTCOffset = dateTimeFormat(Date.now(), {
timeZone: options.timezone,
format: 'Z',
}).replace(':', '');
const validMetricsQueries = metricQueries
.filter(this.filterMetricQuery)
.map((q: CloudWatchMetricsQuery): MetricQuery => {
const migratedQuery = migrateMetricQuery(q);
const migratedAndIterpolatedQuery = this.replaceMetricQueryVars(migratedQuery, options.scopedVars);
return {
timezoneUTCOffset,
intervalMs: options.intervalMs,
maxDataPoints: options.maxDataPoints,
...migratedAndIterpolatedQuery,
type: 'timeSeriesQuery',
datasource: this.ref,
};
});
// No valid targets, return the empty result to save a round trip.
if (isEmpty(validMetricsQueries)) {
return of({ data: [] });
}
const request = {
from: options?.range?.from.valueOf().toString(),
to: options?.range?.to.valueOf().toString(),
queries: validMetricsQueries,
};
return this.performTimeSeriesQuery(request, options.range);
};
interpolateMetricsQueryVariables(
query: CloudWatchMetricsQuery,
scopedVars: ScopedVars
): Pick<
CloudWatchMetricsQuery,
'alias' | 'metricName' | 'namespace' | 'period' | 'dimensions' | 'sqlExpression' | 'expression'
> {
return {
alias: this.replaceVariableAndDisplayWarningIfMulti(query.alias, scopedVars),
metricName: this.replaceVariableAndDisplayWarningIfMulti(query.metricName, scopedVars),
namespace: this.replaceVariableAndDisplayWarningIfMulti(query.namespace, scopedVars),
period: this.replaceVariableAndDisplayWarningIfMulti(query.period, scopedVars),
expression: this.templateSrv.replace(query.expression, scopedVars),
sqlExpression: this.replaceVariableAndDisplayWarningIfMulti(query.sqlExpression, scopedVars),
dimensions: this.convertDimensionFormat(query.dimensions ?? {}, scopedVars),
};
}
performTimeSeriesQuery(request: MetricRequest, { from, to }: TimeRange): Observable<DataQueryResponse> {
return this.awsRequest(this.dsQueryEndpoint, request).pipe(
map((res) => {
const dataframes: DataFrame[] = toDataQueryResponse({ data: res }).data;
if (!dataframes || dataframes.length <= 0) {
return { data: [] };
}
const lastError = findLast(res.results, (v) => !!v.error);
dataframes.forEach((frame) => {
frame.fields.forEach((field) => {
if (field.type === FieldType.time) {
// field.config.interval is populated in order for Grafana to fill in null values at frame intervals
field.config.interval = frame.meta?.custom?.period * 1000;
}
});
});
return {
data: dataframes,
error: lastError ? { message: lastError.error } : undefined,
};
}),
catchError((err: DataQueryError<CloudWatchMetricsQuery>) => {
const isFrameError = err.data?.results;
// Error is not frame specific
if (!isFrameError && err.data && err.data.message === 'Metric request error' && err.data.error) {
err.message = err.data.error;
return throwError(() => err);
}
// The error is either for a specific frame or for all the frames
const results: Array<{ error?: string }> = Object.values(err.data?.results ?? {});
const firstErrorResult = results.find((r) => r.error);
if (firstErrorResult) {
err.message = firstErrorResult.error;
}
if (results.some((r) => r.error && /^Throttling:.*/.test(r.error))) {
const failedRedIds = Object.keys(err.data?.results ?? {});
const regionsAffected = Object.values(request.queries).reduce(
(res: string[], { refId, region }) =>
(refId && !failedRedIds.includes(refId)) || res.includes(region) ? res : [...res, region],
[]
);
regionsAffected.forEach((region) => {
const actualRegion = this.getActualRegion(region);
if (actualRegion) {
this.debouncedAlert(this.instanceSettings.name, actualRegion);
}
});
}
return throwError(() => err);
})
);
}
filterMetricQuery(query: CloudWatchMetricsQuery): boolean {
return filterMetricsQuery(query);
}
replaceMetricQueryVars(query: CloudWatchMetricsQuery, scopedVars: ScopedVars): CloudWatchMetricsQuery {
query.region = this.templateSrv.replace(this.getActualRegion(query.region), scopedVars);
query.namespace = this.replaceVariableAndDisplayWarningIfMulti(query.namespace, scopedVars, true, 'namespace');
query.metricName = this.replaceVariableAndDisplayWarningIfMulti(query.metricName, scopedVars, true, 'metric name');
query.dimensions = this.convertDimensionFormat(query.dimensions ?? {}, scopedVars);
query.statistic = this.templateSrv.replace(query.statistic, scopedVars);
query.period = String(this.getPeriod(query, scopedVars)); // use string format for period in graph query, and alerting
query.id = this.templateSrv.replace(query.id, scopedVars);
query.expression = this.templateSrv.replace(query.expression, scopedVars);
query.sqlExpression = this.templateSrv.replace(query.sqlExpression, scopedVars, 'raw');
if (query.accountId) {
query.accountId = this.templateSrv.replace(query.accountId, scopedVars);
}
return query;
}
getPeriod(target: CloudWatchMetricsQuery, scopedVars: ScopedVars) {
let period = this.templateSrv.replace(target.period, scopedVars);
if (period && period.toLowerCase() !== 'auto') {
let p: number;
if (/^\d+$/.test(period)) {
p = parseInt(period, 10);
} else {
p = rangeUtil.intervalToSeconds(period);
}
if (p < 1) {
p = 1;
}
return String(p);
}
return period;
}
}
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0069267540238797665,
0.0006946717039681971,
0.00016354015679098666,
0.0001732035307213664,
0.0014769957633689046
]
|
{
"id": 3,
"code_window": [
" })),\n",
" }).pipe(\n",
" map((r) => {\n",
" const frames = toDataQueryResponse({ data: r }).data;\n",
" return { data: frames };\n",
" })\n",
" );\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const frames = toDataQueryResponse(r).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchAnnotationQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 38
} | <svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" viewBox="0 0 24 24"><path d="M19,2H5C3.3,2,2,3.3,2,5v14c0,1.7,1.3,3,3,3h14c1.7,0,3-1.3,3-3V5C22,3.3,20.7,2,19,2z M8,17c0,0.6-0.4,1-1,1s-1-0.4-1-1v-4c0-0.6,0.4-1,1-1s1,0.4,1,1V17z M13,17c0,0.6-0.4,1-1,1s-1-0.4-1-1V7c0-0.6,0.4-1,1-1s1,0.4,1,1V17z M18,17c0,0.6-0.4,1-1,1s-1-0.4-1-1v-6c0-0.6,0.4-1,1-1s1,0.4,1,1V17z"/></svg> | public/img/icons/solid/chart.svg | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00016667073941789567,
0.00016667073941789567,
0.00016667073941789567,
0.00016667073941789567,
0
]
|
{
"id": 3,
"code_window": [
" })),\n",
" }).pipe(\n",
" map((r) => {\n",
" const frames = toDataQueryResponse({ data: r }).data;\n",
" return { data: frames };\n",
" })\n",
" );\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const frames = toDataQueryResponse(r).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchAnnotationQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 38
} | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19,11H5a1,1,0,0,0,0,2H19a1,1,0,0,0,0-2Z"/></svg> | public/img/icons/unicons/minus.svg | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.000167596954270266,
0.000167596954270266,
0.000167596954270266,
0.000167596954270266,
0
]
|
{
"id": 3,
"code_window": [
" })),\n",
" }).pipe(\n",
" map((r) => {\n",
" const frames = toDataQueryResponse({ data: r }).data;\n",
" return { data: frames };\n",
" })\n",
" );\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const frames = toDataQueryResponse(r).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchAnnotationQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 38
} | import { Meta, Story, Preview, Props } from '@storybook/addon-docs/blocks';
import { CodeEditor } from './CodeEditor';
<Meta title="MDX|CodeEditor" component={CodeEditor} />
# CodeEditor
Monaco Code editor
| packages/grafana-ui/src/components/Monaco/CodeEditor.mdx | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017406517872586846,
0.00017406517872586846,
0.00017406517872586846,
0.00017406517872586846,
0
]
|
{
"id": 4,
"code_window": [
"\n",
" return this.awsRequest(this.dsQueryEndpoint, requestParams, {\n",
" 'X-Cache-Skip': 'true',\n",
" }).pipe(\n",
" map((response) => resultsToDataFrames({ data: response })),\n",
" catchError((err: FetchError) => {\n",
" if (config.featureToggles.datasourceQueryMultiStatus && err.status === 207) {\n",
" throw err;\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" map((response) => resultsToDataFrames(response)),\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchLogsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 303
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00990631990134716,
0.0010404022177681327,
0.00016327791672665626,
0.00017013824253808707,
0.0025932323187589645
]
|
{
"id": 4,
"code_window": [
"\n",
" return this.awsRequest(this.dsQueryEndpoint, requestParams, {\n",
" 'X-Cache-Skip': 'true',\n",
" }).pipe(\n",
" map((response) => resultsToDataFrames({ data: response })),\n",
" catchError((err: FetchError) => {\n",
" if (config.featureToggles.datasourceQueryMultiStatus && err.status === 207) {\n",
" throw err;\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" map((response) => resultsToDataFrames(response)),\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchLogsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 303
} | {
"status": "success",
"data": {
"resultType": "vector",
"result": [
{
"metric": { "level": "error", "location": "moon"},
"value": [1645029699, "+Inf"]
},
{
"metric": { "level": "info", "location": "moon" },
"value": [1645029699, "-Inf"]
},
{
"metric": { "level": "debug", "location": "moon" },
"value": [1645029699, "NaN"]
}
]
}
}
| pkg/tsdb/loki/testdata/vector_special_values.json | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017420563381165266,
0.00017215817933902144,
0.0001695972605375573,
0.00017267164366785437,
0.000001916074097607634
]
|
{
"id": 4,
"code_window": [
"\n",
" return this.awsRequest(this.dsQueryEndpoint, requestParams, {\n",
" 'X-Cache-Skip': 'true',\n",
" }).pipe(\n",
" map((response) => resultsToDataFrames({ data: response })),\n",
" catchError((err: FetchError) => {\n",
" if (config.featureToggles.datasourceQueryMultiStatus && err.status === 207) {\n",
" throw err;\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" map((response) => resultsToDataFrames(response)),\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchLogsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 303
} | package service
import (
"context"
"fmt"
"time"
"github.com/grafana/grafana/pkg/infra/db"
"github.com/grafana/grafana/pkg/infra/localcache"
"github.com/grafana/grafana/pkg/infra/log"
"github.com/grafana/grafana/pkg/services/datasources"
"github.com/grafana/grafana/pkg/services/user"
)
const (
DefaultCacheTTL = 5 * time.Second
)
func ProvideCacheService(cacheService *localcache.CacheService, sqlStore db.DB) *CacheServiceImpl {
return &CacheServiceImpl{
logger: log.New("datasources"),
cacheTTL: DefaultCacheTTL,
CacheService: cacheService,
SQLStore: sqlStore,
}
}
type CacheServiceImpl struct {
logger log.Logger
cacheTTL time.Duration
CacheService *localcache.CacheService
SQLStore db.DB
}
func (dc *CacheServiceImpl) GetDatasource(
ctx context.Context,
datasourceID int64,
user *user.SignedInUser,
skipCache bool,
) (*datasources.DataSource, error) {
cacheKey := idKey(datasourceID)
if !skipCache {
if cached, found := dc.CacheService.Get(cacheKey); found {
ds := cached.(*datasources.DataSource)
if ds.OrgID == user.OrgID {
return ds, nil
}
}
}
dc.logger.FromContext(ctx).Debug("Querying for data source via SQL store", "id", datasourceID, "orgId", user.OrgID)
query := &datasources.GetDataSourceQuery{ID: datasourceID, OrgID: user.OrgID}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
ds, err := ss.GetDataSource(ctx, query)
if err != nil {
return nil, err
}
if ds.UID != "" {
dc.CacheService.Set(uidKey(ds.OrgID, ds.UID), ds, time.Second*5)
}
dc.CacheService.Set(cacheKey, ds, dc.cacheTTL)
return ds, nil
}
func (dc *CacheServiceImpl) GetDatasourceByUID(
ctx context.Context,
datasourceUID string,
user *user.SignedInUser,
skipCache bool,
) (*datasources.DataSource, error) {
if datasourceUID == "" {
return nil, fmt.Errorf("can not get data source by uid, uid is empty")
}
if user.OrgID == 0 {
return nil, fmt.Errorf("can not get data source by uid, orgId is missing")
}
uidCacheKey := uidKey(user.OrgID, datasourceUID)
if !skipCache {
if cached, found := dc.CacheService.Get(uidCacheKey); found {
ds := cached.(*datasources.DataSource)
if ds.OrgID == user.OrgID {
return ds, nil
}
}
}
dc.logger.FromContext(ctx).Debug("Querying for data source via SQL store", "uid", datasourceUID, "orgId", user.OrgID)
query := &datasources.GetDataSourceQuery{UID: datasourceUID, OrgID: user.OrgID}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
ds, err := ss.GetDataSource(ctx, query)
if err != nil {
return nil, err
}
dc.CacheService.Set(uidCacheKey, ds, dc.cacheTTL)
dc.CacheService.Set(idKey(ds.ID), ds, dc.cacheTTL)
return ds, nil
}
func idKey(id int64) string {
return fmt.Sprintf("ds-%d", id)
}
func uidKey(orgID int64, uid string) string {
return fmt.Sprintf("ds-orgid-uid-%d-%s", orgID, uid)
}
| pkg/services/datasources/service/cache.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00030911804060451686,
0.0001827932574087754,
0.0001655790110817179,
0.00016946524556260556,
0.00003862285666400567
]
|
{
"id": 4,
"code_window": [
"\n",
" return this.awsRequest(this.dsQueryEndpoint, requestParams, {\n",
" 'X-Cache-Skip': 'true',\n",
" }).pipe(\n",
" map((response) => resultsToDataFrames({ data: response })),\n",
" catchError((err: FetchError) => {\n",
" if (config.featureToggles.datasourceQueryMultiStatus && err.status === 207) {\n",
" throw err;\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" map((response) => resultsToDataFrames(response)),\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchLogsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 303
} | import React, { useState } from 'react';
import { NavModelItem } from '@grafana/data';
import { locationService } from '@grafana/runtime';
import { Page } from 'app/core/components/PageNew/Page';
import { LinkSettingsEdit, LinkSettingsList } from '../LinksSettings';
import { newLink } from '../LinksSettings/LinkSettingsEdit';
import { SettingsPageProps } from './types';
export type LinkSettingsMode = 'list' | 'new' | 'edit';
export function LinksSettings({ dashboard, sectionNav, editIndex }: SettingsPageProps) {
const [isNew, setIsNew] = useState<boolean>(false);
const onGoBack = () => {
setIsNew(false);
locationService.partial({ editIndex: undefined });
};
const onNew = () => {
dashboard.links = [...dashboard.links, { ...newLink }];
setIsNew(true);
locationService.partial({ editIndex: dashboard.links.length - 1 });
};
const onEdit = (idx: number) => {
setIsNew(false);
locationService.partial({ editIndex: idx });
};
const isEditing = editIndex !== undefined;
let pageNav: NavModelItem | undefined;
if (isEditing) {
const title = isNew ? 'New link' : 'Edit link';
const description = isNew ? 'Create a new link on your dashboard' : 'Edit a specific link of your dashboard';
pageNav = {
text: title,
subTitle: description,
};
}
return (
<Page navModel={sectionNav} pageNav={pageNav}>
{!isEditing && <LinkSettingsList dashboard={dashboard} onNew={onNew} onEdit={onEdit} />}
{isEditing && <LinkSettingsEdit dashboard={dashboard} editLinkIdx={editIndex} onGoBack={onGoBack} />}
</Page>
);
}
| public/app/features/dashboard/components/DashboardSettings/LinksSettings.tsx | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017525443399790674,
0.00017233804101124406,
0.00016857187438290566,
0.0001730518415570259,
0.000002482974423401174
]
|
{
"id": 5,
"code_window": [
" performTimeSeriesQuery(request: MetricRequest, { from, to }: TimeRange): Observable<DataQueryResponse> {\n",
" return this.awsRequest(this.dsQueryEndpoint, request).pipe(\n",
" map((res) => {\n",
" const dataframes: DataFrame[] = toDataQueryResponse({ data: res }).data;\n",
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const dataframes: DataFrame[] = toDataQueryResponse(res).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 119
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.005582463461905718,
0.0007845911895856261,
0.00016318111738655716,
0.00017243126058019698,
0.0015438708942383528
]
|
{
"id": 5,
"code_window": [
" performTimeSeriesQuery(request: MetricRequest, { from, to }: TimeRange): Observable<DataQueryResponse> {\n",
" return this.awsRequest(this.dsQueryEndpoint, request).pipe(\n",
" map((res) => {\n",
" const dataframes: DataFrame[] = toDataQueryResponse({ data: res }).data;\n",
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const dataframes: DataFrame[] = toDataQueryResponse(res).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 119
} | // Libraries
import React, { useEffect } from 'react';
import { PageLayoutType } from '@grafana/data';
import { Page } from 'app/core/components/Page/Page';
import PageLoader from 'app/core/components/PageLoader/PageLoader';
import { GrafanaRouteComponentProps } from 'app/core/navigation/types';
import { getDashboardLoader } from './DashboardsLoader';
export interface Props extends GrafanaRouteComponentProps<{ uid: string }> {}
export const DashboardScenePage = ({ match }: Props) => {
const loader = getDashboardLoader();
const { dashboard, isLoading } = loader.useState();
useEffect(() => {
loader.load(match.params.uid);
return () => {
loader.clearState();
};
}, [loader, match.params.uid]);
if (!dashboard) {
return (
<Page layout={PageLayoutType.Canvas}>
{isLoading && <PageLoader />}
{!isLoading && <h2>Dashboard not found</h2>}
</Page>
);
}
return <dashboard.Component model={dashboard} />;
};
export default DashboardScenePage;
| public/app/features/scenes/dashboard/DashboardScenePage.tsx | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017759080219548196,
0.00017465268319938332,
0.00017310469411313534,
0.0001739576255204156,
0.000001750612682371866
]
|
{
"id": 5,
"code_window": [
" performTimeSeriesQuery(request: MetricRequest, { from, to }: TimeRange): Observable<DataQueryResponse> {\n",
" return this.awsRequest(this.dsQueryEndpoint, request).pipe(\n",
" map((res) => {\n",
" const dataframes: DataFrame[] = toDataQueryResponse({ data: res }).data;\n",
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const dataframes: DataFrame[] = toDataQueryResponse(res).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 119
} | package errutil
import (
"bytes"
"fmt"
"text/template"
)
// Template is an extended Base for when using templating to construct
// error messages.
type Template struct {
Base Base
logTemplate *template.Template
publicTemplate *template.Template
}
// TemplateData contains data for constructing an Error based on a
// Template.
type TemplateData struct {
Private map[string]interface{}
Public map[string]interface{}
Error error
}
// Template provides templating for converting Base to Error.
// This is useful where the public payload is populated with fields that
// should be present in the internal error representation.
func (b Base) Template(pattern string, opts ...TemplateOpt) (Template, error) {
tmpl, err := template.New(b.messageID + "~private").Parse(pattern)
if err != nil {
return Template{}, err
}
t := Template{
Base: b,
logTemplate: tmpl,
}
for _, o := range opts {
t, err = o(t)
if err != nil {
return Template{}, err
}
}
return t, nil
}
type TemplateOpt func(Template) (Template, error)
// MustTemplate panics if the template for Template cannot be compiled.
//
// Only useful for global or package level initialization of [Template].
func (b Base) MustTemplate(pattern string, opts ...TemplateOpt) Template {
res, err := b.Template(pattern, opts...)
if err != nil {
panic(err)
}
return res
}
// WithPublic provides templating for the user facing error message based
// on only the fields available in TemplateData.Public.
//
// Used as a functional option to [Base.Template].
func WithPublic(pattern string) TemplateOpt {
return func(t Template) (Template, error) {
var err error
t.publicTemplate, err = template.New(t.Base.messageID + "~public").Parse(pattern)
return t, err
}
}
// WithPublicFromLog copies over the template for the log message to be
// used for the user facing error message.
// TemplateData.Error and TemplateData.Private will not be populated
// when rendering the public message.
//
// Used as a functional option to [Base.Template].
func WithPublicFromLog() TemplateOpt {
return func(t Template) (Template, error) {
t.publicTemplate = t.logTemplate
return t, nil
}
}
// Build returns a new [Error] based on the base [Template] and the
// provided [TemplateData], wrapping the error in TemplateData.Error.
//
// Build can fail and return an error that is not of type Error.
func (t Template) Build(data TemplateData) error {
if t.logTemplate == nil {
return fmt.Errorf("cannot initialize error using missing template")
}
buf := bytes.Buffer{}
err := t.logTemplate.Execute(&buf, data)
if err != nil {
return err
}
pubBuf := bytes.Buffer{}
if t.publicTemplate != nil {
err := t.publicTemplate.Execute(&pubBuf, TemplateData{Public: data.Public})
if err != nil {
return err
}
}
e := t.Base.Errorf("%s", buf.String())
e.PublicMessage = pubBuf.String()
e.PublicPayload = data.Public
e.Underlying = data.Error
return e
}
func (t Template) Error() string {
return t.Base.Error()
}
| pkg/util/errutil/template.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0006309965392574668,
0.00020594193483702838,
0.00016367198259104043,
0.00017065752763301134,
0.00012276253255549818
]
|
{
"id": 5,
"code_window": [
" performTimeSeriesQuery(request: MetricRequest, { from, to }: TimeRange): Observable<DataQueryResponse> {\n",
" return this.awsRequest(this.dsQueryEndpoint, request).pipe(\n",
" map((res) => {\n",
" const dataframes: DataFrame[] = toDataQueryResponse({ data: res }).data;\n",
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" const dataframes: DataFrame[] = toDataQueryResponse(res).data;\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 119
} | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M11,7H10V6A1,1,0,0,0,8,6V7H7A1,1,0,0,0,7,9H8v1a1,1,0,0,0,2,0V9h1a1,1,0,0,0,0-2Zm2,11h4a1,1,0,0,0,0-2H13a1,1,0,0,0,0,2ZM19,2H5A3,3,0,0,0,2,5V19a3,3,0,0,0,3,3H19a3,3,0,0,0,3-3V5A3,3,0,0,0,19,2ZM4,18.59V5A1,1,0,0,1,5,4H18.59ZM20,19a1,1,0,0,1-1,1H5.41L20,5.41Z"/></svg> | public/img/icons/unicons/exposure-increase.svg | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017381673387717456,
0.00017381673387717456,
0.00017381673387717456,
0.00017381673387717456,
0
]
|
{
"id": 6,
"code_window": [
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n",
"\n",
" const lastError = findLast(res.results, (v) => !!v.error);\n",
"\n",
" dataframes.forEach((frame) => {\n",
" frame.fields.forEach((field) => {\n",
" if (field.type === FieldType.time) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" const lastError = findLast(res.data.results, (v) => !!v.error);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 124
} | import Prism, { Grammar } from 'prismjs';
import { lastValueFrom } from 'rxjs';
import { AbsoluteTimeRange, HistoryItem, LanguageProvider } from '@grafana/data';
import { CompletionItemGroup, SearchFunctionType, Token, TypeaheadInput, TypeaheadOutput } from '@grafana/ui';
import { getTemplateSrv } from 'app/features/templating/template_srv';
import { CloudWatchDatasource } from '../../datasource';
import { CloudWatchQuery, LogGroup, TSDBResponse } from '../../types';
import { interpolateStringArrayUsingSingleOrMultiValuedVariable } from '../../utils/templateVariableUtils';
import syntax, {
AGGREGATION_FUNCTIONS_STATS,
BOOLEAN_FUNCTIONS,
DATETIME_FUNCTIONS,
FIELD_AND_FILTER_FUNCTIONS,
IP_FUNCTIONS,
NUMERIC_OPERATORS,
QUERY_COMMANDS,
STRING_FUNCTIONS,
} from './syntax';
export type CloudWatchHistoryItem = HistoryItem<CloudWatchQuery>;
type TypeaheadContext = {
history?: CloudWatchHistoryItem[];
absoluteRange?: AbsoluteTimeRange;
logGroups?: LogGroup[];
region: string;
};
export class CloudWatchLogsLanguageProvider extends LanguageProvider {
started = false;
declare initialRange: AbsoluteTimeRange;
datasource: CloudWatchDatasource;
constructor(datasource: CloudWatchDatasource, initialValues?: any) {
super();
this.datasource = datasource;
Object.assign(this, initialValues);
}
// Strip syntax chars
cleanText = (s: string) => s.replace(/[()]/g, '').trim();
getSyntax(): Grammar {
return syntax;
}
request = (url: string, params?: any): Promise<TSDBResponse> => {
return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));
};
start = () => {
if (!this.startTask) {
this.startTask = Promise.resolve().then(() => {
this.started = true;
return [];
});
}
return this.startTask;
};
isStatsQuery(query: string): boolean {
const grammar = this.getSyntax();
const tokens = Prism.tokenize(query, grammar) ?? [];
return !!tokens.find(
(token) =>
typeof token !== 'string' &&
token.content.toString().toLowerCase() === 'stats' &&
token.type === 'query-command'
);
}
/**
* Return suggestions based on input that can be then plugged into a typeahead dropdown.
* Keep this DOM-free for testing
* @param input
* @param context Is optional in types but is required in case we are doing getLabelCompletionItems
* @param context.absoluteRange Required in case we are doing getLabelCompletionItems
* @param context.history Optional used only in getEmptyCompletionItems
*/
async provideCompletionItems(input: TypeaheadInput, context?: TypeaheadContext): Promise<TypeaheadOutput> {
const { value } = input;
// Get tokens
const tokens = value?.data.get('tokens');
if (!tokens || !tokens.length) {
return { suggestions: [] };
}
const curToken: Token = tokens.filter(
(token: any) =>
token.offsets.start <= value!.selection?.start?.offset && token.offsets.end >= value!.selection?.start?.offset
)[0];
const isFirstToken = !curToken.prev;
const prevToken = prevNonWhitespaceToken(curToken);
const isCommandStart = isFirstToken || (!isFirstToken && prevToken?.types.includes('command-separator'));
if (isCommandStart) {
return this.getCommandCompletionItems();
}
if (isInsideFunctionParenthesis(curToken)) {
return await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
}
if (isAfterKeyword('by', curToken)) {
return this.handleKeyword(context);
}
if (prevToken?.types.includes('comparison-operator')) {
return this.handleComparison(context);
}
const commandToken = previousCommandToken(curToken);
if (commandToken) {
return await this.handleCommand(commandToken, curToken, context);
}
return {
suggestions: [],
};
}
private fetchFields = async (logGroups: LogGroup[], region: string): Promise<string[]> => {
const interpolatedLogGroups = interpolateStringArrayUsingSingleOrMultiValuedVariable(
getTemplateSrv(),
logGroups.map((lg) => lg.name),
{},
'text'
);
const results = await Promise.all(
interpolatedLogGroups.map((logGroupName) =>
this.datasource.resources
.getLogGroupFields({ logGroupName, region })
.then((fields) => fields.filter((f) => f).map((f) => f.value.name ?? ''))
)
);
return results.flat();
};
private handleKeyword = async (context?: TypeaheadContext): Promise<TypeaheadOutput> => {
const suggs = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const functionSuggestions: CompletionItemGroup[] = [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: STRING_FUNCTIONS.concat(DATETIME_FUNCTIONS, IP_FUNCTIONS),
},
];
suggs.suggestions.push(...functionSuggestions);
return suggs;
};
private handleCommand = async (
commandToken: Token,
curToken: Token,
context?: TypeaheadContext
): Promise<TypeaheadOutput> => {
const queryCommand = commandToken.content.toLowerCase();
const prevToken = prevNonWhitespaceToken(curToken);
const currentTokenIsFirstArg = prevToken === commandToken;
if (queryCommand === 'sort') {
return this.handleSortCommand(currentTokenIsFirstArg, curToken, context);
}
if (queryCommand === 'parse') {
if (currentTokenIsFirstArg) {
return await this.getFieldCompletionItems(context?.logGroups ?? [], context?.region || 'default');
}
}
const currentTokenIsAfterCommandAndEmpty = isTokenType(commandToken.next, 'whitespace') && !commandToken.next?.next;
const currentTokenIsAfterCommand =
currentTokenIsAfterCommandAndEmpty || nextNonWhitespaceToken(commandToken) === curToken;
const currentTokenIsComma = isTokenType(curToken, 'punctuation', ',');
const currentTokenIsCommaOrAfterComma = currentTokenIsComma || isTokenType(prevToken, 'punctuation', ',');
// We only show suggestions if we are after a command or after a comma which is a field separator
if (!(currentTokenIsAfterCommand || currentTokenIsCommaOrAfterComma)) {
return { suggestions: [] };
}
if (['display', 'fields'].includes(queryCommand)) {
const typeaheadOutput = await this.getFieldCompletionItems(
context?.logGroups ?? [],
context?.region || 'default'
);
typeaheadOutput.suggestions.push(...this.getFieldAndFilterFunctionCompletionItems().suggestions);
return typeaheadOutput;
}
if (queryCommand === 'stats') {
const typeaheadOutput = this.getStatsAggCompletionItems();
if (currentTokenIsComma || currentTokenIsAfterCommandAndEmpty) {
typeaheadOutput?.suggestions.forEach((group) => {
group.skipFilter = true;
});
}
return typeaheadOutput;
}
if (queryCommand === 'filter' && currentTokenIsFirstArg) {
const sugg = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const boolFuncs = this.getBoolFuncCompletionItems();
sugg.suggestions.push(...boolFuncs.suggestions);
return sugg;
}
return { suggestions: [] };
};
private async handleSortCommand(
isFirstArgument: boolean,
curToken: Token,
context?: TypeaheadContext
): Promise<TypeaheadOutput> {
if (isFirstArgument) {
return await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
} else if (isTokenType(prevNonWhitespaceToken(curToken), 'field-name')) {
// suggest sort options
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Sort Order',
items: [
{
label: 'asc',
},
{ label: 'desc' },
],
},
],
};
}
return { suggestions: [] };
}
private handleComparison = async (context?: TypeaheadContext) => {
const fieldsSuggestions = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const comparisonSuggestions = this.getComparisonCompletionItems();
fieldsSuggestions.suggestions.push(...comparisonSuggestions.suggestions);
return fieldsSuggestions;
};
private getCommandCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [{ searchFunctionType: SearchFunctionType.Prefix, label: 'Commands', items: QUERY_COMMANDS }],
};
};
private getFieldAndFilterFunctionCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{ searchFunctionType: SearchFunctionType.Prefix, label: 'Functions', items: FIELD_AND_FILTER_FUNCTIONS },
],
};
};
private getStatsAggCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{ searchFunctionType: SearchFunctionType.Prefix, label: 'Functions', items: AGGREGATION_FUNCTIONS_STATS },
],
};
};
private getBoolFuncCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: BOOLEAN_FUNCTIONS,
},
],
};
};
private getComparisonCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: NUMERIC_OPERATORS.concat(BOOLEAN_FUNCTIONS),
},
],
};
};
private getFieldCompletionItems = async (
logGroups: LogGroup[] | undefined,
region: string
): Promise<TypeaheadOutput> => {
if (!logGroups) {
return { suggestions: [] };
}
const fields = await this.fetchFields(logGroups, region);
return {
suggestions: [
{
label: 'Fields',
items: fields.map((field) => ({
label: field,
insertText: field.match(/@?[_a-zA-Z]+[_.0-9a-zA-Z]*/) ? undefined : `\`${field}\``,
})),
},
],
};
};
}
function nextNonWhitespaceToken(token: Token): Token | null {
let curToken = token;
while (curToken.next) {
if (curToken.next.types.includes('whitespace')) {
curToken = curToken.next;
} else {
return curToken.next;
}
}
return null;
}
function prevNonWhitespaceToken(token: Token): Token | null {
let curToken = token;
while (curToken.prev) {
if (isTokenType(curToken.prev, 'whitespace')) {
curToken = curToken.prev;
} else {
return curToken.prev;
}
}
return null;
}
function previousCommandToken(startToken: Token): Token | null {
let thisToken = startToken;
while (!!thisToken.prev) {
thisToken = thisToken.prev;
if (
thisToken.types.includes('query-command') &&
(!thisToken.prev || isTokenType(prevNonWhitespaceToken(thisToken), 'command-separator'))
) {
return thisToken;
}
}
return null;
}
const funcsWithFieldArgs = [
'avg',
'count',
'count_distinct',
'earliest',
'latest',
'sortsFirst',
'sortsLast',
'max',
'min',
'pct',
'stddev',
'ispresent',
'fromMillis',
'toMillis',
'isempty',
'isblank',
'isValidIp',
'isValidIpV4',
'isValidIpV6',
'isIpInSubnet',
'isIpv4InSubnet',
'isIpv6InSubnet',
].map((funcName) => funcName.toLowerCase());
/**
* Returns true if cursor is currently inside a function parenthesis for example `count(|)` or `count(@mess|)` should
* return true.
*/
function isInsideFunctionParenthesis(curToken: Token): boolean {
const prevToken = prevNonWhitespaceToken(curToken);
if (!prevToken) {
return false;
}
const parenthesisToken = curToken.content === '(' ? curToken : prevToken.content === '(' ? prevToken : undefined;
if (parenthesisToken) {
const maybeFunctionToken = prevNonWhitespaceToken(parenthesisToken);
if (maybeFunctionToken) {
return (
funcsWithFieldArgs.includes(maybeFunctionToken.content.toLowerCase()) &&
maybeFunctionToken.types.includes('function')
);
}
}
return false;
}
function isAfterKeyword(keyword: string, token: Token): boolean {
const maybeKeyword = getPreviousTokenExcluding(token, [
'whitespace',
'function',
'punctuation',
'field-name',
'number',
]);
if (isTokenType(maybeKeyword, 'keyword', 'by')) {
const prev = getPreviousTokenExcluding(token, ['whitespace']);
if (prev === maybeKeyword || isTokenType(prev, 'punctuation', ',')) {
return true;
}
}
return false;
}
function isTokenType(token: Token | undefined | null, type: string, content?: string): boolean {
if (!token?.types.includes(type)) {
return false;
}
if (content) {
if (token?.content.toLowerCase() !== content) {
return false;
}
}
return true;
}
type TokenDef = string | { type: string; value: string };
function getPreviousTokenExcluding(token: Token, exclude: TokenDef[]): Token | undefined | null {
let curToken = token.prev;
main: while (curToken) {
for (const item of exclude) {
if (typeof item === 'string') {
if (curToken.types.includes(item)) {
curToken = curToken.prev;
continue main;
}
} else {
if (curToken.types.includes(item.type) && curToken.content.toLowerCase() === item.value) {
curToken = curToken.prev;
continue main;
}
}
}
break;
}
return curToken;
}
| public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017633153765928,
0.00017168356862384826,
0.0001630353945074603,
0.0001728088391246274,
0.0000031981783195078606
]
|
{
"id": 6,
"code_window": [
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n",
"\n",
" const lastError = findLast(res.results, (v) => !!v.error);\n",
"\n",
" dataframes.forEach((frame) => {\n",
" frame.fields.forEach((field) => {\n",
" if (field.type === FieldType.time) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" const lastError = findLast(res.data.results, (v) => !!v.error);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 124
} | package metrics
import (
"runtime"
"github.com/prometheus/client_golang/prometheus"
"github.com/grafana/grafana/pkg/infra/metrics/metricutil"
pubdash "github.com/grafana/grafana/pkg/services/publicdashboards/models"
"github.com/grafana/grafana/pkg/setting"
)
// ExporterName is used as namespace for exposing prometheus metrics
const ExporterName = "grafana"
var (
// MInstanceStart is a metric counter for started instances
MInstanceStart prometheus.Counter
// MPageStatus is a metric page http response status
MPageStatus *prometheus.CounterVec
// MApiStatus is a metric api http response status
MApiStatus *prometheus.CounterVec
// MProxyStatus is a metric proxy http response status
MProxyStatus *prometheus.CounterVec
// MApiUserSignUpStarted is a metric amount of users who started the signup flow
MApiUserSignUpStarted prometheus.Counter
// MApiUserSignUpCompleted is a metric amount of users who completed the signup flow
MApiUserSignUpCompleted prometheus.Counter
// MApiUserSignUpInvite is a metric amount of users who have been invited
MApiUserSignUpInvite prometheus.Counter
// MApiDashboardSave is a metric summary for dashboard save duration
MApiDashboardSave prometheus.Summary
// MApiDashboardGet is a metric summary for dashboard get duration
MApiDashboardGet prometheus.Summary
// MApiDashboardSearch is a metric summary for dashboard search duration
MApiDashboardSearch prometheus.Summary
// MApiAdminUserCreate is a metric api admin user created counter
MApiAdminUserCreate prometheus.Counter
// MApiLoginPost is a metric api login post counter
MApiLoginPost prometheus.Counter
// MApiLoginOAuth is a metric api login oauth counter
MApiLoginOAuth prometheus.Counter
// MApiLoginSAML is a metric api login SAML counter
MApiLoginSAML prometheus.Counter
// MApiOrgCreate is a metric api org created counter
MApiOrgCreate prometheus.Counter
// MApiDashboardSnapshotCreate is a metric dashboard snapshots created
MApiDashboardSnapshotCreate prometheus.Counter
// MApiDashboardSnapshotExternal is a metric external dashboard snapshots created
MApiDashboardSnapshotExternal prometheus.Counter
// MApiDashboardSnapshotGet is a metric loaded dashboards
MApiDashboardSnapshotGet prometheus.Counter
// MApiDashboardInsert is a metric dashboards inserted
MApiDashboardInsert prometheus.Counter
// MAlertingResultState is a metric alert execution result counter
MAlertingResultState *prometheus.CounterVec
// MAlertingNotificationSent is a metric counter for how many alert notifications been sent
MAlertingNotificationSent *prometheus.CounterVec
// MAlertingNotificationSent is a metric counter for how many alert notifications that failed
MAlertingNotificationFailed *prometheus.CounterVec
// MAwsCloudWatchGetMetricStatistics is a metric counter for getting metric statistics from aws
MAwsCloudWatchGetMetricStatistics prometheus.Counter
// MAwsCloudWatchListMetrics is a metric counter for getting list of metrics from aws
MAwsCloudWatchListMetrics prometheus.Counter
// MAwsCloudWatchGetMetricData is a metric counter for getting metric data time series from aws
MAwsCloudWatchGetMetricData prometheus.Counter
// MDBDataSourceQueryByID is a metric counter for getting datasource by id
MDBDataSourceQueryByID prometheus.Counter
// LDAPUsersSyncExecutionTime is a metric summary for LDAP users sync execution duration
LDAPUsersSyncExecutionTime prometheus.Summary
// MRenderingRequestTotal is a metric counter for image rendering requests
MRenderingRequestTotal *prometheus.CounterVec
// MRenderingQueue is a metric gauge for image rendering queue size
MRenderingQueue prometheus.Gauge
// MAccessEvaluationCount is a metric gauge for total number of evaluation requests
MAccessEvaluationCount prometheus.Counter
// MPublicDashboardRequestCount is a metric counter for public dashboards requests
MPublicDashboardRequestCount prometheus.Counter
// MPublicDashboardDatasourceQuerySuccess is a metric counter for successful queries labelled by datasource
MPublicDashboardDatasourceQuerySuccess *prometheus.CounterVec
)
// Timers
var (
// MDataSourceProxyReqTimer is a metric summary for dataproxy request duration
MDataSourceProxyReqTimer prometheus.Summary
// MAlertingExecutionTime is a metric summary of alert execution duration
MAlertingExecutionTime prometheus.Summary
// MRenderingSummary is a metric summary for image rendering request duration
MRenderingSummary *prometheus.SummaryVec
// MAccessPermissionsSummary is a metric summary for loading permissions request duration when evaluating access
MAccessPermissionsSummary prometheus.Histogram
// MAccessEvaluationsSummary is a metric summary for loading permissions request duration when evaluating access
MAccessEvaluationsSummary prometheus.Histogram
)
// StatTotals
var (
// MAlertingActiveAlerts is a metric amount of active alerts
MAlertingActiveAlerts prometheus.Gauge
// MStatTotalDashboards is a metric total amount of dashboards
MStatTotalDashboards prometheus.Gauge
// MStatTotalFolders is a metric total amount of folders
MStatTotalFolders prometheus.Gauge
// MStatTotalUsers is a metric total amount of users
MStatTotalUsers prometheus.Gauge
// MStatTotalTeams is a metric total amount of teams
MStatTotalTeams prometheus.Gauge
// MStatActiveUsers is a metric number of active users
MStatActiveUsers prometheus.Gauge
// MStatTotalOrgs is a metric total amount of orgs
MStatTotalOrgs prometheus.Gauge
// MStatTotalPlaylists is a metric total amount of playlists
MStatTotalPlaylists prometheus.Gauge
// StatsTotalViewers is a metric total amount of viewers
StatsTotalViewers prometheus.Gauge
// StatsTotalEditors is a metric total amount of editors
StatsTotalEditors prometheus.Gauge
// StatsTotalAdmins is a metric total amount of admins
StatsTotalAdmins prometheus.Gauge
// StatsTotalActiveViewers is a metric total amount of viewers
StatsTotalActiveViewers prometheus.Gauge
// StatsTotalActiveEditors is a metric total amount of active editors
StatsTotalActiveEditors prometheus.Gauge
// StatsTotalActiveAdmins is a metric total amount of active admins
StatsTotalActiveAdmins prometheus.Gauge
// StatsTotalDataSources is a metric total number of defined datasources, labeled by pluginId
StatsTotalDataSources *prometheus.GaugeVec
// StatsTotalAnnotations is a metric of total number of annotations stored in Grafana.
StatsTotalAnnotations prometheus.Gauge
// StatsTotalAlertRules is a metric of total number of alert rules stored in Grafana.
StatsTotalAlertRules prometheus.Gauge
// StatsTotalDashboardVersions is a metric of total number of dashboard versions stored in Grafana.
StatsTotalDashboardVersions prometheus.Gauge
grafanaPluginBuildInfoDesc *prometheus.GaugeVec
// StatsTotalLibraryPanels is a metric of total number of library panels stored in Grafana.
StatsTotalLibraryPanels prometheus.Gauge
// StatsTotalLibraryVariables is a metric of total number of library variables stored in Grafana.
StatsTotalLibraryVariables prometheus.Gauge
// StatsTotalDataKeys is a metric of total number of data keys stored in Grafana.
StatsTotalDataKeys *prometheus.GaugeVec
// MStatTotalPublicDashboards is a metric total amount of public dashboards
MStatTotalPublicDashboards prometheus.Gauge
)
func init() {
httpStatusCodes := []string{"200", "404", "500", "unknown"}
objectiveMap := map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}
MInstanceStart = prometheus.NewCounter(prometheus.CounterOpts{
Name: "instance_start_total",
Help: "counter for started instances",
Namespace: ExporterName,
})
MPageStatus = metricutil.NewCounterVecStartingAtZero(
prometheus.CounterOpts{
Name: "page_response_status_total",
Help: "page http response status",
Namespace: ExporterName,
}, []string{"code"}, map[string][]string{"code": httpStatusCodes})
MApiStatus = metricutil.NewCounterVecStartingAtZero(
prometheus.CounterOpts{
Name: "api_response_status_total",
Help: "api http response status",
Namespace: ExporterName,
}, []string{"code"}, map[string][]string{"code": httpStatusCodes})
MProxyStatus = metricutil.NewCounterVecStartingAtZero(
prometheus.CounterOpts{
Name: "proxy_response_status_total",
Help: "proxy http response status",
Namespace: ExporterName,
}, []string{"code"}, map[string][]string{"code": httpStatusCodes})
MApiUserSignUpStarted = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_user_signup_started_total",
Help: "amount of users who started the signup flow",
Namespace: ExporterName,
})
MApiUserSignUpCompleted = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_user_signup_completed_total",
Help: "amount of users who completed the signup flow",
Namespace: ExporterName,
})
MApiUserSignUpInvite = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_user_signup_invite_total",
Help: "amount of users who have been invited",
Namespace: ExporterName,
})
MApiDashboardSave = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "api_dashboard_save_milliseconds",
Help: "summary for dashboard save duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MApiDashboardGet = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "api_dashboard_get_milliseconds",
Help: "summary for dashboard get duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MApiDashboardSearch = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "api_dashboard_search_milliseconds",
Help: "summary for dashboard search duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MApiAdminUserCreate = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_admin_user_created_total",
Help: "api admin user created counter",
Namespace: ExporterName,
})
MApiLoginPost = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_login_post_total",
Help: "api login post counter",
Namespace: ExporterName,
})
MApiLoginOAuth = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_login_oauth_total",
Help: "api login oauth counter",
Namespace: ExporterName,
})
MApiLoginSAML = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_login_saml_total",
Help: "api login saml counter",
Namespace: ExporterName,
})
MApiOrgCreate = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_org_create_total",
Help: "api org created counter",
Namespace: ExporterName,
})
MApiDashboardSnapshotCreate = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_dashboard_snapshot_create_total",
Help: "dashboard snapshots created",
Namespace: ExporterName,
})
MApiDashboardSnapshotExternal = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_dashboard_snapshot_external_total",
Help: "external dashboard snapshots created",
Namespace: ExporterName,
})
MApiDashboardSnapshotGet = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_dashboard_snapshot_get_total",
Help: "loaded dashboards",
Namespace: ExporterName,
})
MApiDashboardInsert = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "api_models_dashboard_insert_total",
Help: "dashboards inserted ",
Namespace: ExporterName,
})
MAlertingResultState = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "alerting_result_total",
Help: "alert execution result counter",
Namespace: ExporterName,
}, []string{"state"})
MAlertingNotificationSent = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "alerting_notification_sent_total",
Help: "counter for how many alert notifications have been sent",
Namespace: ExporterName,
}, []string{"type"})
MAlertingNotificationFailed = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "alerting_notification_failed_total",
Help: "counter for how many alert notifications have failed",
Namespace: ExporterName,
}, []string{"type"})
MAwsCloudWatchGetMetricStatistics = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "aws_cloudwatch_get_metric_statistics_total",
Help: "counter for getting metric statistics from aws",
Namespace: ExporterName,
})
MAwsCloudWatchListMetrics = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "aws_cloudwatch_list_metrics_total",
Help: "counter for getting list of metrics from aws",
Namespace: ExporterName,
})
MAwsCloudWatchGetMetricData = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "aws_cloudwatch_get_metric_data_total",
Help: "counter for getting metric data time series from aws",
Namespace: ExporterName,
})
MDBDataSourceQueryByID = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "db_datasource_query_by_id_total",
Help: "counter for getting datasource by id",
Namespace: ExporterName,
})
LDAPUsersSyncExecutionTime = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "ldap_users_sync_execution_time",
Help: "summary for LDAP users sync execution duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MRenderingRequestTotal = prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "rendering_request_total",
Help: "counter for rendering requests",
Namespace: ExporterName,
},
[]string{"status", "type"},
)
MRenderingSummary = prometheus.NewSummaryVec(
prometheus.SummaryOpts{
Name: "rendering_request_duration_milliseconds",
Help: "summary of rendering request duration",
Objectives: objectiveMap,
Namespace: ExporterName,
},
[]string{"status", "type"},
)
MRenderingQueue = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "rendering_queue_size",
Help: "size of rendering queue",
Namespace: ExporterName,
})
MDataSourceProxyReqTimer = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "api_dataproxy_request_all_milliseconds",
Help: "summary for dataproxy request duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MAlertingExecutionTime = prometheus.NewSummary(prometheus.SummaryOpts{
Name: "alerting_execution_time_milliseconds",
Help: "summary of alert execution duration",
Objectives: objectiveMap,
Namespace: ExporterName,
})
MAlertingActiveAlerts = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "alerting_active_alerts",
Help: "amount of active alerts",
Namespace: ExporterName,
})
MPublicDashboardRequestCount = metricutil.NewCounterStartingAtZero(prometheus.CounterOpts{
Name: "public_dashboard_request_count",
Help: "counter for public dashboards requests",
Namespace: ExporterName,
})
MPublicDashboardDatasourceQuerySuccess = metricutil.NewCounterVecStartingAtZero(prometheus.CounterOpts{
Name: "public_dashboard_datasource_query_success",
Help: "counter for queries to public dashboard datasources labelled by datasource type and success status success/failed",
Namespace: ExporterName,
}, []string{"datasource", "status"}, map[string][]string{"status": pubdash.QueryResultStatuses})
MStatTotalDashboards = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_dashboard",
Help: "total amount of dashboards",
Namespace: ExporterName,
})
MStatTotalFolders = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_folder",
Help: "total amount of folders",
Namespace: ExporterName,
})
MStatTotalUsers = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_total_users",
Help: "total amount of users",
Namespace: ExporterName,
})
MStatTotalTeams = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_total_teams",
Help: "total amount of teams",
Namespace: ExporterName,
})
MStatActiveUsers = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_active_users",
Help: "number of active users",
Namespace: ExporterName,
})
MStatTotalOrgs = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_total_orgs",
Help: "total amount of orgs",
Namespace: ExporterName,
})
MStatTotalPlaylists = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_total_playlists",
Help: "total amount of playlists",
Namespace: ExporterName,
})
StatsTotalViewers = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_viewers",
Help: "total amount of viewers",
Namespace: ExporterName,
})
StatsTotalEditors = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_editors",
Help: "total amount of editors",
Namespace: ExporterName,
})
StatsTotalAdmins = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_admins",
Help: "total amount of admins",
Namespace: ExporterName,
})
StatsTotalActiveViewers = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_active_viewers",
Help: "total amount of viewers",
Namespace: ExporterName,
})
StatsTotalActiveEditors = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_active_editors",
Help: "total amount of active editors",
Namespace: ExporterName,
})
StatsTotalActiveAdmins = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_active_admins",
Help: "total amount of active admins",
Namespace: ExporterName,
})
StatsTotalDataSources = prometheus.NewGaugeVec(prometheus.GaugeOpts{
Name: "stat_totals_datasource",
Help: "total number of defined datasources, labeled by pluginId",
Namespace: ExporterName,
}, []string{"plugin_id"})
grafanaPluginBuildInfoDesc = prometheus.NewGaugeVec(prometheus.GaugeOpts{
Name: "plugin_build_info",
Help: "A metric with a constant '1' value labeled by pluginId, pluginType and version from which Grafana plugin was built",
Namespace: ExporterName,
}, []string{"plugin_id", "plugin_type", "version", "signature_status"})
StatsTotalDashboardVersions = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_dashboard_versions",
Help: "total amount of dashboard versions in the database",
Namespace: ExporterName,
})
StatsTotalAnnotations = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_annotations",
Help: "total amount of annotations in the database",
Namespace: ExporterName,
})
StatsTotalAlertRules = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_alert_rules",
Help: "total amount of alert rules in the database",
Namespace: ExporterName,
})
MAccessPermissionsSummary = prometheus.NewHistogram(prometheus.HistogramOpts{
Name: "access_permissions_duration",
Help: "Histogram for the runtime of permissions check function.",
Buckets: prometheus.ExponentialBuckets(0.00001, 4, 10),
})
MAccessEvaluationsSummary = prometheus.NewHistogram(prometheus.HistogramOpts{
Name: "access_evaluation_duration",
Help: "Histogram for the runtime of evaluation function.",
Buckets: prometheus.ExponentialBuckets(0.00001, 4, 10),
})
MAccessEvaluationCount = prometheus.NewCounter(prometheus.CounterOpts{
Name: "access_evaluation_count",
Help: "number of evaluation calls",
Namespace: ExporterName,
})
StatsTotalLibraryPanels = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_library_panels",
Help: "total amount of library panels in the database",
Namespace: ExporterName,
})
StatsTotalLibraryVariables = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_library_variables",
Help: "total amount of library variables in the database",
Namespace: ExporterName,
})
StatsTotalDataKeys = prometheus.NewGaugeVec(prometheus.GaugeOpts{
Name: "stat_totals_data_keys",
Help: "total amount of data keys in the database",
Namespace: ExporterName,
}, []string{"active"})
MStatTotalPublicDashboards = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "stat_totals_public_dashboard",
Help: "total amount of public dashboards",
Namespace: ExporterName,
})
}
// SetBuildInformation sets the build information for this binary
func SetBuildInformation(version, revision, branch string, buildTimestamp int64) {
edition := "oss"
if setting.IsEnterprise {
edition = "enterprise"
}
grafanaBuildVersion := prometheus.NewGaugeVec(prometheus.GaugeOpts{
Name: "build_info",
Help: "A metric with a constant '1' value labeled by version, revision, branch, and goversion from which Grafana was built",
Namespace: ExporterName,
}, []string{"version", "revision", "branch", "goversion", "edition"})
grafanaBuildTimestamp := prometheus.NewGaugeVec(prometheus.GaugeOpts{
Name: "build_timestamp",
Help: "A metric exposing when the binary was built in epoch",
Namespace: ExporterName,
}, []string{"version", "revision", "branch", "goversion", "edition"})
prometheus.MustRegister(grafanaBuildVersion, grafanaBuildTimestamp)
grafanaBuildVersion.WithLabelValues(version, revision, branch, runtime.Version(), edition).Set(1)
grafanaBuildTimestamp.WithLabelValues(version, revision, branch, runtime.Version(), edition).Set(float64(buildTimestamp))
}
// SetEnvironmentInformation exposes environment values provided by the operators as an `_info` metric.
// If there are no environment metrics labels configured, this metric will not be exposed.
func SetEnvironmentInformation(labels map[string]string) error {
if len(labels) == 0 {
return nil
}
grafanaEnvironmentInfo := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "environment_info",
Help: "A metric with a constant '1' value labeled by environment information about the running instance.",
Namespace: ExporterName,
ConstLabels: labels,
})
prometheus.MustRegister(grafanaEnvironmentInfo)
grafanaEnvironmentInfo.Set(1)
return nil
}
func SetPluginBuildInformation(pluginID, pluginType, version, signatureStatus string) {
grafanaPluginBuildInfoDesc.WithLabelValues(pluginID, pluginType, version, signatureStatus).Set(1)
}
func initMetricVars() {
prometheus.MustRegister(
MInstanceStart,
MPageStatus,
MApiStatus,
MProxyStatus,
MApiUserSignUpStarted,
MApiUserSignUpCompleted,
MApiUserSignUpInvite,
MApiDashboardSave,
MApiDashboardGet,
MApiDashboardSearch,
MDataSourceProxyReqTimer,
MAlertingExecutionTime,
MApiAdminUserCreate,
MApiLoginPost,
MApiLoginOAuth,
MApiLoginSAML,
MApiOrgCreate,
MApiDashboardSnapshotCreate,
MApiDashboardSnapshotExternal,
MApiDashboardSnapshotGet,
MApiDashboardInsert,
MAlertingResultState,
MAlertingNotificationSent,
MAlertingNotificationFailed,
MAwsCloudWatchGetMetricStatistics,
MAwsCloudWatchListMetrics,
MAwsCloudWatchGetMetricData,
MDBDataSourceQueryByID,
LDAPUsersSyncExecutionTime,
MRenderingRequestTotal,
MRenderingSummary,
MRenderingQueue,
MAccessPermissionsSummary,
MAccessEvaluationsSummary,
MAlertingActiveAlerts,
MStatTotalDashboards,
MStatTotalFolders,
MStatTotalUsers,
MStatTotalTeams,
MStatActiveUsers,
MStatTotalOrgs,
MStatTotalPlaylists,
StatsTotalViewers,
StatsTotalEditors,
StatsTotalAdmins,
StatsTotalActiveViewers,
StatsTotalActiveEditors,
StatsTotalActiveAdmins,
StatsTotalDataSources,
grafanaPluginBuildInfoDesc,
StatsTotalDashboardVersions,
StatsTotalAnnotations,
MAccessEvaluationCount,
StatsTotalLibraryPanels,
StatsTotalLibraryVariables,
StatsTotalDataKeys,
MStatTotalPublicDashboards,
MPublicDashboardRequestCount,
MPublicDashboardDatasourceQuerySuccess,
)
}
| pkg/infra/metrics/metrics.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017728439706843346,
0.00017198940622620285,
0.00016304828750435263,
0.00017245582421310246,
0.0000029638306386914337
]
|
{
"id": 6,
"code_window": [
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n",
"\n",
" const lastError = findLast(res.results, (v) => !!v.error);\n",
"\n",
" dataframes.forEach((frame) => {\n",
" frame.fields.forEach((field) => {\n",
" if (field.type === FieldType.time) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" const lastError = findLast(res.data.results, (v) => !!v.error);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 124
} | ---
title: View org list as server admin
---
{{< docs/list >}}
{{< docs/shared "manage-users/view-server-org-list.md" >}}
1. Click the name of the organization that you want to edit.
{{< /docs/list >}}
| docs/sources/shared/manage-users/view-server-org-list-and-edit.md | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017397888586856425,
0.0001726210757624358,
0.00017126328020822257,
0.0001726210757624358,
0.00000135780283017084
]
|
{
"id": 6,
"code_window": [
" if (!dataframes || dataframes.length <= 0) {\n",
" return { data: [] };\n",
" }\n",
"\n",
" const lastError = findLast(res.results, (v) => !!v.error);\n",
"\n",
" dataframes.forEach((frame) => {\n",
" frame.fields.forEach((field) => {\n",
" if (field.type === FieldType.time) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" const lastError = findLast(res.data.results, (v) => !!v.error);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchMetricsQueryRunner.ts",
"type": "replace",
"edit_start_line_idx": 124
} | import { getProperty } from './feed';
import { Feed } from './types';
export function parseAtomFeed(txt: string): Feed {
const domParser = new DOMParser();
const doc = domParser.parseFromString(txt, 'text/xml');
const feed: Feed = {
items: Array.from(doc.querySelectorAll('entry')).map((node) => ({
title: getProperty(node, 'title'),
link: node.querySelector('link')?.getAttribute('href') ?? '',
content: getProperty(node, 'content'),
pubDate: getProperty(node, 'published'),
ogImage: node.querySelector("meta[property='og:image']")?.getAttribute('content'),
})),
};
return feed;
}
| public/app/plugins/panel/news/atom.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017629505600780249,
0.00017523264978080988,
0.0001741702581057325,
0.00017523264978080988,
0.000001062398951034993
]
|
{
"id": 7,
"code_window": [
"import { Observable, map } from 'rxjs';\n",
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n"
],
"labels": [
"replace",
"keep",
"keep"
],
"after_edit": [
"import { Observable } from 'rxjs';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 0
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.9573764204978943,
0.07398543506860733,
0.00016438361490145326,
0.00026190225617028773,
0.25501319766044617
]
|
{
"id": 7,
"code_window": [
"import { Observable, map } from 'rxjs';\n",
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n"
],
"labels": [
"replace",
"keep",
"keep"
],
"after_edit": [
"import { Observable } from 'rxjs';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 0
} | export const createTestOrgIfNotExists = (client) => {
let orgId = 0;
let res = client.orgs.getByName('k6');
if (res.status === 404) {
res = client.orgs.create('k6');
if (res.status !== 200) {
throw new Error('Expected 200 response status when creating org');
}
return res.json().orgId;
}
// This can happen e.g. in Hosted Grafana instances, where even admins
// cannot see organisations
if (res.status !== 200) {
console.info(`unable to get orgs from instance, continuing with default orgId ${orgId}`);
return orgId;
}
return res.json().id;
};
export const createTestdataDatasourceIfNotExists = (client) => {
const payload = {
access: 'proxy',
isDefault: false,
name: 'k6-testdata',
type: 'testdata',
};
let res = client.datasources.getByName(payload.name);
if (res.status === 404) {
res = client.datasources.create(payload);
}
if (res.status !== 200) {
throw new Error(`expected 200 response status when creating datasource, got ${res.status}`);
}
return res.json().id;
};
| devenv/docker/loadtest/modules/util.js | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00021808063320349902,
0.0001814166025724262,
0.00016885646618902683,
0.00017285216017626226,
0.000018494542018743232
]
|
{
"id": 7,
"code_window": [
"import { Observable, map } from 'rxjs';\n",
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n"
],
"labels": [
"replace",
"keep",
"keep"
],
"after_edit": [
"import { Observable } from 'rxjs';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 0
} | package api
import (
"context"
"encoding/json"
"fmt"
"net/http"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/oauth2"
"github.com/grafana/grafana/pkg/api/dtos"
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/api/routing"
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/infra/db"
"github.com/grafana/grafana/pkg/infra/db/dbtest"
"github.com/grafana/grafana/pkg/infra/usagestats"
acmock "github.com/grafana/grafana/pkg/services/accesscontrol/mock"
contextmodel "github.com/grafana/grafana/pkg/services/contexthandler/model"
"github.com/grafana/grafana/pkg/services/login"
"github.com/grafana/grafana/pkg/services/login/authinfoservice"
authinfostore "github.com/grafana/grafana/pkg/services/login/authinfoservice/database"
"github.com/grafana/grafana/pkg/services/login/logintest"
"github.com/grafana/grafana/pkg/services/org/orgimpl"
"github.com/grafana/grafana/pkg/services/quota/quotatest"
"github.com/grafana/grafana/pkg/services/searchusers"
"github.com/grafana/grafana/pkg/services/searchusers/filters"
"github.com/grafana/grafana/pkg/services/secrets/database"
secretsManager "github.com/grafana/grafana/pkg/services/secrets/manager"
"github.com/grafana/grafana/pkg/services/supportbundles/supportbundlestest"
"github.com/grafana/grafana/pkg/services/user"
"github.com/grafana/grafana/pkg/services/user/userimpl"
"github.com/grafana/grafana/pkg/services/user/usertest"
"github.com/grafana/grafana/pkg/setting"
)
func TestUserAPIEndpoint_userLoggedIn(t *testing.T) {
settings := setting.NewCfg()
sqlStore := db.InitTestDB(t)
hs := &HTTPServer{
Cfg: settings,
SQLStore: sqlStore,
AccessControl: acmock.New(),
}
mockResult := user.SearchUserQueryResult{
Users: []*user.UserSearchHitDTO{
{Name: "user1"},
{Name: "user2"},
},
TotalCount: 2,
}
mock := dbtest.NewFakeDB()
userMock := usertest.NewUserServiceFake()
loggedInUserScenario(t, "When calling GET on", "api/users/1", "api/users/:id", func(sc *scenarioContext) {
fakeNow := time.Date(2019, 2, 11, 17, 30, 40, 0, time.UTC)
secretsService := secretsManager.SetupTestService(t, database.ProvideSecretsStore(sqlStore))
authInfoStore := authinfostore.ProvideAuthInfoStore(sqlStore, secretsService, userMock)
srv := authinfoservice.ProvideAuthInfoService(
&authinfoservice.OSSUserProtectionImpl{},
authInfoStore,
&usagestats.UsageStatsMock{},
)
hs.authInfoService = srv
orgSvc, err := orgimpl.ProvideService(sqlStore, sqlStore.Cfg, quotatest.New(false, nil))
require.NoError(t, err)
userSvc, err := userimpl.ProvideService(sqlStore, orgSvc, sc.cfg, nil, nil, quotatest.New(false, nil), supportbundlestest.NewFakeBundleService())
require.NoError(t, err)
hs.userService = userSvc
createUserCmd := user.CreateUserCommand{
Email: fmt.Sprint("user", "@test.com"),
Name: "user",
Login: "loginuser",
IsAdmin: true,
}
usr, err := userSvc.Create(context.Background(), &createUserCmd)
require.NoError(t, err)
sc.handlerFunc = hs.GetUserByID
token := &oauth2.Token{
AccessToken: "testaccess",
RefreshToken: "testrefresh",
Expiry: time.Now(),
TokenType: "Bearer",
}
idToken := "testidtoken"
token = token.WithExtra(map[string]interface{}{"id_token": idToken})
userlogin := "loginuser"
query := &login.GetUserByAuthInfoQuery{AuthModule: "test", AuthId: "test", UserLookupParams: login.UserLookupParams{Login: &userlogin}}
cmd := &login.UpdateAuthInfoCommand{
UserId: usr.ID,
AuthId: query.AuthId,
AuthModule: query.AuthModule,
OAuthToken: token,
}
err = srv.UpdateAuthInfo(context.Background(), cmd)
require.NoError(t, err)
avatarUrl := dtos.GetGravatarUrl("@test.com")
sc.fakeReqWithParams("GET", sc.url, map[string]string{"id": fmt.Sprintf("%v", usr.ID)}).exec()
expected := user.UserProfileDTO{
ID: 1,
Email: "[email protected]",
Name: "user",
Login: "loginuser",
OrgID: 1,
IsGrafanaAdmin: true,
AuthLabels: []string{},
CreatedAt: fakeNow,
UpdatedAt: fakeNow,
AvatarURL: avatarUrl,
}
var resp user.UserProfileDTO
require.Equal(t, http.StatusOK, sc.resp.Code)
err = json.Unmarshal(sc.resp.Body.Bytes(), &resp)
require.NoError(t, err)
resp.CreatedAt = fakeNow
resp.UpdatedAt = fakeNow
resp.AvatarURL = avatarUrl
require.EqualValues(t, expected, resp)
}, mock)
loggedInUserScenario(t, "When calling GET on", "/api/users/lookup", "/api/users/lookup", func(sc *scenarioContext) {
createUserCmd := user.CreateUserCommand{
Email: fmt.Sprint("admin", "@test.com"),
Name: "admin",
Login: "admin",
IsAdmin: true,
}
orgSvc, err := orgimpl.ProvideService(sqlStore, sqlStore.Cfg, quotatest.New(false, nil))
require.NoError(t, err)
userSvc, err := userimpl.ProvideService(sqlStore, orgSvc, sc.cfg, nil, nil, quotatest.New(false, nil), supportbundlestest.NewFakeBundleService())
require.NoError(t, err)
_, err = userSvc.Create(context.Background(), &createUserCmd)
require.Nil(t, err)
sc.handlerFunc = hs.GetUserByLoginOrEmail
userMock := usertest.NewUserServiceFake()
userMock.ExpectedUser = &user.User{ID: 2}
sc.userService = userMock
hs.userService = userMock
sc.fakeReqWithParams("GET", sc.url, map[string]string{"loginOrEmail": "[email protected]"}).exec()
var resp user.UserProfileDTO
require.Equal(t, http.StatusOK, sc.resp.Code)
err = json.Unmarshal(sc.resp.Body.Bytes(), &resp)
require.NoError(t, err)
}, mock)
loggedInUserScenario(t, "When calling GET on", "/api/users", "/api/users", func(sc *scenarioContext) {
userMock.ExpectedSearchUsers = mockResult
searchUsersService := searchusers.ProvideUsersService(filters.ProvideOSSSearchUserFilter(), userMock)
sc.handlerFunc = searchUsersService.SearchUsers
sc.fakeReqWithParams("GET", sc.url, map[string]string{}).exec()
respJSON, err := simplejson.NewJson(sc.resp.Body.Bytes())
require.NoError(t, err)
assert.Equal(t, 2, len(respJSON.MustArray()))
}, mock)
loggedInUserScenario(t, "When calling GET with page and limit querystring parameters on", "/api/users", "/api/users", func(sc *scenarioContext) {
userMock.ExpectedSearchUsers = mockResult
searchUsersService := searchusers.ProvideUsersService(filters.ProvideOSSSearchUserFilter(), userMock)
sc.handlerFunc = searchUsersService.SearchUsers
sc.fakeReqWithParams("GET", sc.url, map[string]string{"perpage": "10", "page": "2"}).exec()
respJSON, err := simplejson.NewJson(sc.resp.Body.Bytes())
require.NoError(t, err)
assert.Equal(t, 2, len(respJSON.MustArray()))
}, mock)
loggedInUserScenario(t, "When calling GET on", "/api/users/search", "/api/users/search", func(sc *scenarioContext) {
userMock.ExpectedSearchUsers = mockResult
searchUsersService := searchusers.ProvideUsersService(filters.ProvideOSSSearchUserFilter(), userMock)
sc.handlerFunc = searchUsersService.SearchUsersWithPaging
sc.fakeReqWithParams("GET", sc.url, map[string]string{}).exec()
respJSON, err := simplejson.NewJson(sc.resp.Body.Bytes())
require.NoError(t, err)
assert.Equal(t, 1, respJSON.Get("page").MustInt())
assert.Equal(t, 1000, respJSON.Get("perPage").MustInt())
assert.Equal(t, 2, respJSON.Get("totalCount").MustInt())
assert.Equal(t, 2, len(respJSON.Get("users").MustArray()))
}, mock)
loggedInUserScenario(t, "When calling GET with page and perpage querystring parameters on", "/api/users/search", "/api/users/search", func(sc *scenarioContext) {
userMock.ExpectedSearchUsers = mockResult
searchUsersService := searchusers.ProvideUsersService(filters.ProvideOSSSearchUserFilter(), userMock)
sc.handlerFunc = searchUsersService.SearchUsersWithPaging
sc.fakeReqWithParams("GET", sc.url, map[string]string{"perpage": "10", "page": "2"}).exec()
respJSON, err := simplejson.NewJson(sc.resp.Body.Bytes())
require.NoError(t, err)
assert.Equal(t, 2, respJSON.Get("page").MustInt())
assert.Equal(t, 10, respJSON.Get("perPage").MustInt())
}, mock)
}
func TestHTTPServer_UpdateUser(t *testing.T) {
settings := setting.NewCfg()
sqlStore := db.InitTestDB(t)
hs := &HTTPServer{
Cfg: settings,
SQLStore: sqlStore,
AccessControl: acmock.New(),
}
updateUserCommand := user.UpdateUserCommand{
Email: fmt.Sprint("admin", "@test.com"),
Name: "admin",
Login: "admin",
UserID: 1,
}
updateUserScenario(t, updateUserContext{
desc: "Should return 403 when the current User is an external user",
url: "/api/users/1",
routePattern: "/api/users/:id",
cmd: updateUserCommand,
fn: func(sc *scenarioContext) {
sc.authInfoService.ExpectedUserAuth = &login.UserAuth{}
sc.fakeReqWithParams("PUT", sc.url, map[string]string{"id": "1"}).exec()
assert.Equal(t, 403, sc.resp.Code)
},
}, hs)
}
type updateUserContext struct {
desc string
url string
routePattern string
cmd user.UpdateUserCommand
fn scenarioFunc
}
func updateUserScenario(t *testing.T, ctx updateUserContext, hs *HTTPServer) {
t.Run(fmt.Sprintf("%s %s", ctx.desc, ctx.url), func(t *testing.T) {
sc := setupScenarioContext(t, ctx.url)
sc.authInfoService = &logintest.AuthInfoServiceFake{}
hs.authInfoService = sc.authInfoService
sc.defaultHandler = routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(ctx.cmd)
c.Req.Header.Add("Content-Type", "application/json")
sc.context = c
sc.context.OrgID = testOrgID
sc.context.UserID = testUserID
return hs.UpdateUser(c)
})
sc.m.Put(ctx.routePattern, sc.defaultHandler)
ctx.fn(sc)
})
}
func TestHTTPServer_UpdateSignedInUser(t *testing.T) {
settings := setting.NewCfg()
sqlStore := db.InitTestDB(t)
hs := &HTTPServer{
Cfg: settings,
SQLStore: sqlStore,
AccessControl: acmock.New(),
}
updateUserCommand := user.UpdateUserCommand{
Email: fmt.Sprint("admin", "@test.com"),
Name: "admin",
Login: "admin",
UserID: 1,
}
updateSignedInUserScenario(t, updateUserContext{
desc: "Should return 403 when the current User is an external user",
url: "/api/users/",
routePattern: "/api/users/",
cmd: updateUserCommand,
fn: func(sc *scenarioContext) {
sc.authInfoService.ExpectedUserAuth = &login.UserAuth{}
sc.fakeReqWithParams("PUT", sc.url, map[string]string{"id": "1"}).exec()
assert.Equal(t, 403, sc.resp.Code)
},
}, hs)
}
func updateSignedInUserScenario(t *testing.T, ctx updateUserContext, hs *HTTPServer) {
t.Run(fmt.Sprintf("%s %s", ctx.desc, ctx.url), func(t *testing.T) {
sc := setupScenarioContext(t, ctx.url)
sc.authInfoService = &logintest.AuthInfoServiceFake{}
hs.authInfoService = sc.authInfoService
sc.defaultHandler = routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(ctx.cmd)
c.Req.Header.Add("Content-Type", "application/json")
sc.context = c
sc.context.OrgID = testOrgID
sc.context.UserID = testUserID
return hs.UpdateSignedInUser(c)
})
sc.m.Put(ctx.routePattern, sc.defaultHandler)
ctx.fn(sc)
})
}
| pkg/api/user_test.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0002210137463407591,
0.0001721821172395721,
0.00016130598669406027,
0.00016964950191322714,
0.00001111925121222157
]
|
{
"id": 7,
"code_window": [
"import { Observable, map } from 'rxjs';\n",
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n"
],
"labels": [
"replace",
"keep",
"keep"
],
"after_edit": [
"import { Observable } from 'rxjs';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 0
} | package liveplugin
import (
"context"
"fmt"
"github.com/centrifugal/centrifuge"
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana/pkg/services/datasources"
"github.com/grafana/grafana/pkg/services/live/orgchannel"
"github.com/grafana/grafana/pkg/services/live/pipeline"
"github.com/grafana/grafana/pkg/services/pluginsintegration/plugincontext"
"github.com/grafana/grafana/pkg/services/user"
)
type ChannelLocalPublisher struct {
node *centrifuge.Node
pipeline *pipeline.Pipeline
}
func NewChannelLocalPublisher(node *centrifuge.Node, pipeline *pipeline.Pipeline) *ChannelLocalPublisher {
return &ChannelLocalPublisher{node: node, pipeline: pipeline}
}
func (p *ChannelLocalPublisher) PublishLocal(channel string, data []byte) error {
if p.pipeline != nil {
orgID, channelID, err := orgchannel.StripOrgID(channel)
if err != nil {
return err
}
ok, err := p.pipeline.ProcessInput(context.Background(), orgID, channelID, data)
if err != nil {
return err
}
if ok {
// if rule found – we are done here. If not - fall through and process as usual.
return nil
}
}
pub := ¢rifuge.Publication{
Data: data,
}
err := p.node.Hub().BroadcastPublication(channel, pub, centrifuge.StreamPosition{})
if err != nil {
return fmt.Errorf("error publishing %s: %w", string(data), err)
}
return nil
}
type NumLocalSubscribersGetter struct {
node *centrifuge.Node
}
func NewNumLocalSubscribersGetter(node *centrifuge.Node) *NumLocalSubscribersGetter {
return &NumLocalSubscribersGetter{node: node}
}
func (p *NumLocalSubscribersGetter) GetNumLocalSubscribers(channelID string) (int, error) {
return p.node.Hub().NumSubscribers(channelID), nil
}
type ContextGetter struct {
pluginContextProvider *plugincontext.Provider
dataSourceCache datasources.CacheService
}
func NewContextGetter(pluginContextProvider *plugincontext.Provider, dataSourceCache datasources.CacheService) *ContextGetter {
return &ContextGetter{
pluginContextProvider: pluginContextProvider,
dataSourceCache: dataSourceCache,
}
}
func (g *ContextGetter) GetPluginContext(ctx context.Context, user *user.SignedInUser, pluginID string, datasourceUID string, skipCache bool) (backend.PluginContext, bool, error) {
if datasourceUID == "" {
return g.pluginContextProvider.Get(ctx, pluginID, user)
}
ds, err := g.dataSourceCache.GetDatasourceByUID(ctx, datasourceUID, user, skipCache)
if err != nil {
return backend.PluginContext{}, false, fmt.Errorf("%v: %w", "Failed to get datasource", err)
}
return g.pluginContextProvider.GetWithDataSource(ctx, pluginID, user, ds)
}
| pkg/services/live/liveplugin/plugin.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00020019950170535594,
0.00017572725482750684,
0.000166817000717856,
0.0001691894285613671,
0.000012118033737351652
]
|
{
"id": 8,
"code_window": [
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n",
"import { getBackendSrv } from '@grafana/runtime';\n",
"import { notifyApp } from 'app/core/actions';\n",
"import { createErrorNotification } from 'app/core/copy/appNotification';\n",
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { BackendDataSourceResponse, FetchResponse, getBackendSrv } from '@grafana/runtime';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 3
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.8949090242385864,
0.06960755586624146,
0.00017399780335836112,
0.000557596969883889,
0.2382449507713318
]
|
{
"id": 8,
"code_window": [
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n",
"import { getBackendSrv } from '@grafana/runtime';\n",
"import { notifyApp } from 'app/core/actions';\n",
"import { createErrorNotification } from 'app/core/copy/appNotification';\n",
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { BackendDataSourceResponse, FetchResponse, getBackendSrv } from '@grafana/runtime';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 3
} | import React, { useContext } from 'react';
import { GrafanaConfig } from '@grafana/data';
import { LocationService } from '@grafana/runtime/src/services/LocationService';
import { BackendSrv } from '@grafana/runtime/src/services/backendSrv';
import { AppChromeService } from '../components/AppChrome/AppChromeService';
import { KeybindingSrv } from '../services/keybindingSrv';
export interface GrafanaContextType {
backend: BackendSrv;
location: LocationService;
config: GrafanaConfig;
chrome: AppChromeService;
keybindings: KeybindingSrv;
}
export const GrafanaContext = React.createContext<GrafanaContextType | undefined>(undefined);
export function useGrafana(): GrafanaContextType {
const context = useContext(GrafanaContext);
if (!context) {
throw new Error('No GrafanaContext found');
}
return context;
}
| public/app/core/context/GrafanaContext.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0005565311294049025,
0.00030857729143463075,
0.00016943918308243155,
0.00019976151816081256,
0.00017576631216797978
]
|
{
"id": 8,
"code_window": [
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n",
"import { getBackendSrv } from '@grafana/runtime';\n",
"import { notifyApp } from 'app/core/actions';\n",
"import { createErrorNotification } from 'app/core/copy/appNotification';\n",
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { BackendDataSourceResponse, FetchResponse, getBackendSrv } from '@grafana/runtime';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 3
} | package ualert
import (
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/prometheus/alertmanager/pkg/labels"
"github.com/prometheus/common/model"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/components/simplejson"
ngModels "github.com/grafana/grafana/pkg/services/ngalert/models"
)
func TestFilterReceiversForAlert(t *testing.T) {
tc := []struct {
name string
channelIds []uidOrID
receivers map[uidOrID]*PostableApiReceiver
defaultReceivers map[string]struct{}
expected map[string]interface{}
}{
{
name: "when an alert has multiple channels, each should filter for the correct receiver",
channelIds: []uidOrID{"uid1", "uid2"},
receivers: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "recv1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid2": {
Name: "recv2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid3": {
Name: "recv3",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
},
defaultReceivers: map[string]struct{}{},
expected: map[string]interface{}{
"recv1": struct{}{},
"recv2": struct{}{},
},
},
{
name: "when default receivers exist, they should be added to an alert's filtered receivers",
channelIds: []uidOrID{"uid1"},
receivers: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "recv1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid2": {
Name: "recv2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid3": {
Name: "recv3",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
},
defaultReceivers: map[string]struct{}{
"recv2": {},
},
expected: map[string]interface{}{
"recv1": struct{}{}, // From alert
"recv2": struct{}{}, // From default
},
},
{
name: "when an alert has a channels associated by ID instead of UID, it should be included",
channelIds: []uidOrID{int64(42)},
receivers: map[uidOrID]*PostableApiReceiver{
int64(42): {
Name: "recv1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
},
defaultReceivers: map[string]struct{}{},
expected: map[string]interface{}{
"recv1": struct{}{},
},
},
{
name: "when an alert's receivers are covered by the defaults, return nil to use default receiver downstream",
channelIds: []uidOrID{"uid1"},
receivers: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "recv1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid2": {
Name: "recv2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
"uid3": {
Name: "recv3",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
},
defaultReceivers: map[string]struct{}{
"recv1": {},
"recv2": {},
},
expected: nil, // recv1 is already a default
},
}
for _, tt := range tc {
t.Run(tt.name, func(t *testing.T) {
m := newTestMigration(t)
res := m.filterReceiversForAlert("", tt.channelIds, tt.receivers, tt.defaultReceivers)
require.Equal(t, tt.expected, res)
})
}
}
func TestCreateRoute(t *testing.T) {
tc := []struct {
name string
channel *notificationChannel
recv *PostableApiReceiver
expected *Route
}{
{
name: "when a receiver is passed in, the route should regex match based on quoted name with continue=true",
channel: ¬ificationChannel{},
recv: &PostableApiReceiver{
Name: "recv1",
},
expected: &Route{
Receiver: "recv1",
ObjectMatchers: ObjectMatchers{{Type: 2, Name: ContactLabel, Value: `.*"recv1".*`}},
Routes: nil,
Continue: true,
GroupByStr: nil,
RepeatInterval: durationPointer(DisabledRepeatInterval),
},
},
{
name: "notification channel should be escaped for regex in the matcher",
channel: ¬ificationChannel{},
recv: &PostableApiReceiver{
Name: `. ^ $ * + - ? ( ) [ ] { } \ |`,
},
expected: &Route{
Receiver: `. ^ $ * + - ? ( ) [ ] { } \ |`,
ObjectMatchers: ObjectMatchers{{Type: 2, Name: ContactLabel, Value: `.*"\. \^ \$ \* \+ - \? \( \) \[ \] \{ \} \\ \|".*`}},
Routes: nil,
Continue: true,
GroupByStr: nil,
RepeatInterval: durationPointer(DisabledRepeatInterval),
},
},
{
name: "when a channel has sendReminder=true, the route should use the frequency in repeat interval",
channel: ¬ificationChannel{SendReminder: true, Frequency: model.Duration(time.Duration(42) * time.Hour)},
recv: &PostableApiReceiver{
Name: "recv1",
},
expected: &Route{
Receiver: "recv1",
ObjectMatchers: ObjectMatchers{{Type: 2, Name: ContactLabel, Value: `.*"recv1".*`}},
Routes: nil,
Continue: true,
GroupByStr: nil,
RepeatInterval: durationPointer(model.Duration(time.Duration(42) * time.Hour)),
},
},
{
name: "when a channel has sendReminder=false, the route should ignore the frequency in repeat interval and use DisabledRepeatInterval",
channel: ¬ificationChannel{SendReminder: false, Frequency: model.Duration(time.Duration(42) * time.Hour)},
recv: &PostableApiReceiver{
Name: "recv1",
},
expected: &Route{
Receiver: "recv1",
ObjectMatchers: ObjectMatchers{{Type: 2, Name: ContactLabel, Value: `.*"recv1".*`}},
Routes: nil,
Continue: true,
GroupByStr: nil,
RepeatInterval: durationPointer(DisabledRepeatInterval),
},
},
}
for _, tt := range tc {
t.Run(tt.name, func(t *testing.T) {
res, err := createRoute(channelReceiver{
channel: tt.channel,
receiver: tt.recv,
})
require.NoError(t, err)
// Order of nested routes is not guaranteed.
cOpt := []cmp.Option{
cmpopts.SortSlices(func(a, b *Route) bool {
if a.Receiver != b.Receiver {
return a.Receiver < b.Receiver
}
return a.ObjectMatchers[0].Value < b.ObjectMatchers[0].Value
}),
cmpopts.IgnoreUnexported(Route{}, labels.Matcher{}),
}
if !cmp.Equal(tt.expected, res, cOpt...) {
t.Errorf("Unexpected Route: %v", cmp.Diff(tt.expected, res, cOpt...))
}
})
}
}
func createNotChannel(t *testing.T, uid string, id int64, name string) *notificationChannel {
t.Helper()
return ¬ificationChannel{Uid: uid, ID: id, Name: name, Settings: simplejson.New()}
}
func createNotChannelWithReminder(t *testing.T, uid string, id int64, name string, frequency model.Duration) *notificationChannel {
t.Helper()
return ¬ificationChannel{Uid: uid, ID: id, Name: name, SendReminder: true, Frequency: frequency, Settings: simplejson.New()}
}
func TestCreateReceivers(t *testing.T) {
tc := []struct {
name string
allChannels []*notificationChannel
defaultChannels []*notificationChannel
expRecvMap map[uidOrID]*PostableApiReceiver
expRecv []channelReceiver
expErr error
}{
{
name: "when given notification channels migrate them to receivers",
allChannels: []*notificationChannel{createNotChannel(t, "uid1", int64(1), "name1"), createNotChannel(t, "uid2", int64(2), "name2")},
expRecvMap: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "name1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name1"}},
},
"uid2": {
Name: "name2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name2"}},
},
int64(1): {
Name: "name1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name1"}},
},
int64(2): {
Name: "name2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name2"}},
},
},
expRecv: []channelReceiver{
{
channel: createNotChannel(t, "uid1", int64(1), "name1"),
receiver: &PostableApiReceiver{
Name: "name1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name1"}},
},
},
{
channel: createNotChannel(t, "uid2", int64(2), "name2"),
receiver: &PostableApiReceiver{
Name: "name2",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name2"}},
},
},
},
},
{
name: "when given notification channel contains double quote sanitize with underscore",
allChannels: []*notificationChannel{createNotChannel(t, "uid1", int64(1), "name\"1")},
expRecvMap: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
int64(1): {
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
},
expRecv: []channelReceiver{
{
channel: createNotChannel(t, "uid1", int64(1), "name\"1"),
receiver: &PostableApiReceiver{
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
},
},
},
{
name: "when given notification channels collide after sanitization add short hash to end",
allChannels: []*notificationChannel{createNotChannel(t, "uid1", int64(1), "name\"1"), createNotChannel(t, "uid2", int64(2), "name_1")},
expRecvMap: map[uidOrID]*PostableApiReceiver{
"uid1": {
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
"uid2": {
Name: "name_1_dba13d",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1_dba13d"}},
},
int64(1): {
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
int64(2): {
Name: "name_1_dba13d",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1_dba13d"}},
},
},
expRecv: []channelReceiver{
{
channel: createNotChannel(t, "uid1", int64(1), "name\"1"),
receiver: &PostableApiReceiver{
Name: "name_1",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1"}},
},
},
{
channel: createNotChannel(t, "uid2", int64(2), "name_1"),
receiver: &PostableApiReceiver{
Name: "name_1_dba13d",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name_1_dba13d"}},
},
},
},
},
}
for _, tt := range tc {
t.Run(tt.name, func(t *testing.T) {
m := newTestMigration(t)
recvMap, recvs, err := m.createReceivers(tt.allChannels)
if tt.expErr != nil {
require.Error(t, err)
require.EqualError(t, err, tt.expErr.Error())
return
}
require.NoError(t, err)
// We ignore certain fields for the purposes of this test
for _, recv := range recvs {
for _, not := range recv.receiver.GrafanaManagedReceivers {
not.UID = ""
not.Settings = nil
not.SecureSettings = nil
}
}
require.Equal(t, tt.expRecvMap, recvMap)
require.ElementsMatch(t, tt.expRecv, recvs)
})
}
}
func TestCreateDefaultRouteAndReceiver(t *testing.T) {
tc := []struct {
name string
amConfig *PostableUserConfig
defaultChannels []*notificationChannel
expRecv *PostableApiReceiver
expRoute *Route
expErr error
}{
{
name: "when given multiple default notification channels migrate them to a single receiver",
defaultChannels: []*notificationChannel{createNotChannel(t, "uid1", int64(1), "name1"), createNotChannel(t, "uid2", int64(2), "name2")},
expRecv: &PostableApiReceiver{
Name: "autogen-contact-point-default",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name1"}, {Name: "name2"}},
},
expRoute: &Route{
Receiver: "autogen-contact-point-default",
Routes: make([]*Route, 0),
GroupByStr: []string{ngModels.FolderTitleLabel, model.AlertNameLabel},
RepeatInterval: durationPointer(DisabledRepeatInterval),
},
},
{
name: "when given multiple default notification channels migrate them to a single receiver with RepeatInterval set to be the minimum of all channel frequencies",
defaultChannels: []*notificationChannel{
createNotChannelWithReminder(t, "uid1", int64(1), "name1", model.Duration(42)),
createNotChannelWithReminder(t, "uid2", int64(2), "name2", model.Duration(100000)),
},
expRecv: &PostableApiReceiver{
Name: "autogen-contact-point-default",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{{Name: "name1"}, {Name: "name2"}},
},
expRoute: &Route{
Receiver: "autogen-contact-point-default",
Routes: make([]*Route, 0),
GroupByStr: []string{ngModels.FolderTitleLabel, model.AlertNameLabel},
RepeatInterval: durationPointer(model.Duration(42)),
},
},
{
name: "when given no default notification channels create a single empty receiver for default",
defaultChannels: []*notificationChannel{},
expRecv: &PostableApiReceiver{
Name: "autogen-contact-point-default",
GrafanaManagedReceivers: []*PostableGrafanaReceiver{},
},
expRoute: &Route{
Receiver: "autogen-contact-point-default",
Routes: make([]*Route, 0),
GroupByStr: []string{ngModels.FolderTitleLabel, model.AlertNameLabel},
RepeatInterval: nil,
},
},
{
name: "when given a single default notification channels don't create a new default receiver",
defaultChannels: []*notificationChannel{createNotChannel(t, "uid1", int64(1), "name1")},
expRecv: nil,
expRoute: &Route{
Receiver: "name1",
Routes: make([]*Route, 0),
GroupByStr: []string{ngModels.FolderTitleLabel, model.AlertNameLabel},
RepeatInterval: durationPointer(DisabledRepeatInterval),
},
},
{
name: "when given a single default notification channel with SendReminder=true, use the channels Frequency as the RepeatInterval",
defaultChannels: []*notificationChannel{createNotChannelWithReminder(t, "uid1", int64(1), "name1", model.Duration(42))},
expRecv: nil,
expRoute: &Route{
Receiver: "name1",
Routes: make([]*Route, 0),
GroupByStr: []string{ngModels.FolderTitleLabel, model.AlertNameLabel},
RepeatInterval: durationPointer(model.Duration(42)),
},
},
}
for _, tt := range tc {
t.Run(tt.name, func(t *testing.T) {
m := newTestMigration(t)
recv, route, err := m.createDefaultRouteAndReceiver(tt.defaultChannels)
if tt.expErr != nil {
require.Error(t, err)
require.EqualError(t, err, tt.expErr.Error())
return
}
require.NoError(t, err)
// We ignore certain fields for the purposes of this test
if recv != nil {
for _, not := range recv.GrafanaManagedReceivers {
not.UID = ""
not.Settings = nil
not.SecureSettings = nil
}
}
require.Equal(t, tt.expRecv, recv)
require.Equal(t, tt.expRoute, route)
})
}
}
func durationPointer(d model.Duration) *model.Duration {
return &d
}
| pkg/services/sqlstore/migrations/ualert/channel_test.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017664185725152493,
0.00017007703718263656,
0.0001638313988223672,
0.00017015851335600019,
0.000003177726057401742
]
|
{
"id": 8,
"code_window": [
"\n",
"import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';\n",
"import { getBackendSrv } from '@grafana/runtime';\n",
"import { notifyApp } from 'app/core/actions';\n",
"import { createErrorNotification } from 'app/core/copy/appNotification';\n",
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { BackendDataSourceResponse, FetchResponse, getBackendSrv } from '@grafana/runtime';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 3
} | <?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 20.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
width="100px" height="100px" viewBox="0 0 100 100" style="enable-background:new 0 0 100 100;" xml:space="preserve">
<style type="text/css">
.st0{fill:#898989;}
.st1{fill:url(#SVGID_1_);}
</style>
<g>
<path class="st0" d="M0,98V74.4c0-1.1,0.9-2,2-2H98c1.1,0,2,0.9,2,2V98c0,1.1-0.9,2-2,2H2C0.9,100,0,99.1,0,98z"/>
<path class="st0" d="M0,24.7v-22C0,1.2,1.2,0,2.6,0h94.8c1.4,0,2.6,1.2,2.6,2.8v22c0,1.5-1.2,2.8-2.6,2.8H2.6
C1.2,27.5,0,26.3,0,24.7z"/>
<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="50" y1="94.582" x2="50" y2="11.6586">
<stop offset="0" style="stop-color:#FFF23A"/>
<stop offset="4.010540e-02" style="stop-color:#FEE62D"/>
<stop offset="0.1171" style="stop-color:#FED41A"/>
<stop offset="0.1964" style="stop-color:#FDC90F"/>
<stop offset="0.2809" style="stop-color:#FDC60B"/>
<stop offset="0.6685" style="stop-color:#F28F3F"/>
<stop offset="0.8876" style="stop-color:#ED693C"/>
<stop offset="1" style="stop-color:#E83E39"/>
</linearGradient>
<path class="st1" d="M0,61.8V38.2c0-1.1,0.9-2,2-2H98c1.1,0,2,0.9,2,2v23.6c0,1.1-0.9,2-2,2H2C0.9,63.8,0,62.9,0,61.8z"/>
</g>
</svg>
| public/img/icn-row.svg | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017427642887923867,
0.00017337064491584897,
0.00017176649998873472,
0.0001740689913276583,
0.0000011374552286724793
]
|
{
"id": 9,
"code_window": [
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n",
"import { AppNotificationTimeout } from 'app/types';\n",
"\n",
"import memoizedDebounce from '../memoizedDebounce';\n",
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';\n",
"\n",
"export abstract class CloudWatchRequest {\n",
" templateSrv: TemplateSrv;\n",
" ref: DataSourceRef;\n",
" dsQueryEndpoint = '/api/ds/query';\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters } from '../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 11
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.9967684745788574,
0.15987306833267212,
0.00016487040556967258,
0.0010674638906493783,
0.3570806384086609
]
|
{
"id": 9,
"code_window": [
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n",
"import { AppNotificationTimeout } from 'app/types';\n",
"\n",
"import memoizedDebounce from '../memoizedDebounce';\n",
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';\n",
"\n",
"export abstract class CloudWatchRequest {\n",
" templateSrv: TemplateSrv;\n",
" ref: DataSourceRef;\n",
" dsQueryEndpoint = '/api/ds/query';\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters } from '../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 11
} | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M21,20H20V5a1,1,0,0,0-2,0V20H16V9a1,1,0,0,0-2,0V20H12V13a1,1,0,0,0-2,0v7H8V17a1,1,0,0,0-2,0v3H4V3A1,1,0,0,0,2,3V21a1,1,0,0,0,1,1H21a1,1,0,0,0,0-2Z"/></svg> | public/img/icons/unicons/chart-growth.svg | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0001737070269882679,
0.0001737070269882679,
0.0001737070269882679,
0.0001737070269882679,
0
]
|
{
"id": 9,
"code_window": [
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n",
"import { AppNotificationTimeout } from 'app/types';\n",
"\n",
"import memoizedDebounce from '../memoizedDebounce';\n",
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';\n",
"\n",
"export abstract class CloudWatchRequest {\n",
" templateSrv: TemplateSrv;\n",
" ref: DataSourceRef;\n",
" dsQueryEndpoint = '/api/ds/query';\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters } from '../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 11
} | package folder
import (
"context"
)
type Service interface {
// GetChildren returns an array containing all child folders.
GetChildren(ctx context.Context, cmd *GetChildrenQuery) ([]*Folder, error)
// GetParents returns an array containing add parent folders if nested folders are enabled
// otherwise it returns an empty array
GetParents(ctx context.Context, q GetParentsQuery) ([]*Folder, error)
Create(ctx context.Context, cmd *CreateFolderCommand) (*Folder, error)
// GetFolder takes a GetFolderCommand and returns a folder matching the
// request. One of ID, UID, or Title must be included. If multiple values
// are included in the request, Grafana will select one in order of
// specificity (ID, UID, Title).
Get(ctx context.Context, cmd *GetFolderQuery) (*Folder, error)
// Update is used to update a folder's UID, Title and Description. To change
// a folder's parent folder, use Move.
Update(ctx context.Context, cmd *UpdateFolderCommand) (*Folder, error)
Delete(ctx context.Context, cmd *DeleteFolderCommand) error
MakeUserAdmin(ctx context.Context, orgID int64, userID, folderID int64, setViewAndEditPermissions bool) error
// Move changes a folder's parent folder to the requested new parent.
Move(ctx context.Context, cmd *MoveFolderCommand) (*Folder, error)
}
// FolderStore is a folder store.
//
//go:generate mockery --name FolderStore --structname FakeFolderStore --outpkg foldertest --output foldertest --filename folder_store_mock.go
type FolderStore interface {
// GetFolderByTitle retrieves a folder by its title
GetFolderByTitle(ctx context.Context, orgID int64, title string) (*Folder, error)
// GetFolderByUID retrieves a folder by its UID
GetFolderByUID(ctx context.Context, orgID int64, uid string) (*Folder, error)
// GetFolderByID retrieves a folder by its ID
GetFolderByID(ctx context.Context, orgID int64, id int64) (*Folder, error)
}
| pkg/services/folder/service.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00016972360026556998,
0.00016872672131285071,
0.00016681062697898597,
0.00016892039275262505,
0.0000010428973382659024
]
|
{
"id": 9,
"code_window": [
"import { TemplateSrv } from 'app/features/templating/template_srv';\n",
"import { store } from 'app/store/store';\n",
"import { AppNotificationTimeout } from 'app/types';\n",
"\n",
"import memoizedDebounce from '../memoizedDebounce';\n",
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';\n",
"\n",
"export abstract class CloudWatchRequest {\n",
" templateSrv: TemplateSrv;\n",
" ref: DataSourceRef;\n",
" dsQueryEndpoint = '/api/ds/query';\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters } from '../types';\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 11
} | import { DataTransformerConfig } from '@grafana/data';
export interface TransformationsEditorTransformation {
transformation: DataTransformerConfig;
id: string;
}
| public/app/features/dashboard/components/TransformationsEditor/types.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017464438860770315,
0.00017464438860770315,
0.00017464438860770315,
0.00017464438860770315,
0
]
|
{
"id": 10,
"code_window": [
" constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {\n",
" this.templateSrv = templateSrv;\n",
" this.ref = getDataSourceRef(instanceSettings);\n",
" }\n",
"\n",
" awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {\n",
" const options = {\n",
" method: 'POST',\n",
" url,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" awsRequest(\n",
" url: string,\n",
" data: MetricRequest,\n",
" headers: Record<string, string> = {}\n",
" ): Observable<FetchResponse<BackendDataSourceResponse>> {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 27
} | import { Observable, map } from 'rxjs';
import { DataSourceInstanceSettings, DataSourceRef, getDataSourceRef, ScopedVars } from '@grafana/data';
import { getBackendSrv } from '@grafana/runtime';
import { notifyApp } from 'app/core/actions';
import { createErrorNotification } from 'app/core/copy/appNotification';
import { TemplateSrv } from 'app/features/templating/template_srv';
import { store } from 'app/store/store';
import { AppNotificationTimeout } from 'app/types';
import memoizedDebounce from '../memoizedDebounce';
import { CloudWatchJsonData, Dimensions, MetricRequest, MultiFilters, TSDBResponse } from '../types';
export abstract class CloudWatchRequest {
templateSrv: TemplateSrv;
ref: DataSourceRef;
dsQueryEndpoint = '/api/ds/query';
debouncedCustomAlert: (title: string, message: string) => void = memoizedDebounce(
displayCustomError,
AppNotificationTimeout.Error
);
constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {
this.templateSrv = templateSrv;
this.ref = getDataSourceRef(instanceSettings);
}
awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {
const options = {
method: 'POST',
url,
data,
headers,
};
return getBackendSrv()
.fetch<TSDBResponse>(options)
.pipe(map((result) => result.data));
}
convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {
return Object.entries(dimensions).reduce((result, [key, value]) => {
key = this.replaceVariableAndDisplayWarningIfMulti(key, scopedVars, true, 'dimension keys');
if (Array.isArray(value)) {
return { ...result, [key]: value };
}
if (!value) {
return { ...result, [key]: null };
}
const newValues = this.expandVariableToArray(value, scopedVars);
return { ...result, [key]: newValues };
}, {});
}
// get the value for a given template variable
expandVariableToArray(value: string, scopedVars: ScopedVars): string[] {
const variableName = this.templateSrv.getVariableName(value);
const valueVar = this.templateSrv.getVariables().find(({ name }) => {
return name === variableName;
});
if (variableName && valueVar) {
const isMultiVariable =
valueVar?.type === 'custom' || valueVar?.type === 'query' || valueVar?.type === 'datasource';
if (isMultiVariable && valueVar.multi) {
return this.templateSrv.replace(value, scopedVars, 'pipe').split('|');
}
return [this.templateSrv.replace(value, scopedVars)];
}
return [value];
}
convertMultiFilterFormat(multiFilters: MultiFilters, fieldName?: string) {
return Object.entries(multiFilters).reduce((result, [key, values]) => {
const interpolatedKey = this.replaceVariableAndDisplayWarningIfMulti(key, {}, true, fieldName);
if (!values) {
return { ...result, [interpolatedKey]: null };
}
const initialVal: string[] = [];
const newValues = values.reduce((result, value) => {
const vals = this.expandVariableToArray(value, {});
return [...result, ...vals];
}, initialVal);
return { ...result, [interpolatedKey]: newValues };
}, {});
}
replaceVariableAndDisplayWarningIfMulti(
target?: string,
scopedVars?: ScopedVars,
displayErrorIfIsMultiTemplateVariable?: boolean,
fieldName?: string
) {
if (displayErrorIfIsMultiTemplateVariable && !!target) {
const variables = this.templateSrv.getVariables();
const variable = variables.find(({ name }) => name === this.templateSrv.getVariableName(target));
const isMultiVariable =
variable?.type === 'custom' || variable?.type === 'query' || variable?.type === 'datasource';
if (isMultiVariable && variable.multi) {
this.debouncedCustomAlert(
'CloudWatch templating error',
`Multi template variables are not supported for ${fieldName || target}`
);
}
}
return this.templateSrv.replace(target, scopedVars);
}
getActualRegion(region?: string) {
if (region === 'default' || region === undefined || region === '') {
return this.instanceSettings.jsonData.defaultRegion ?? '';
}
return region;
}
getVariables() {
return this.templateSrv.getVariables().map((v) => `$${v.name}`);
}
}
const displayCustomError = (title: string, message: string) =>
store.dispatch(notifyApp(createErrorNotification(title, message)));
| public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.9984966516494751,
0.345736563205719,
0.0001696071121841669,
0.041701216250658035,
0.42992275953292847
]
|
{
"id": 10,
"code_window": [
" constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {\n",
" this.templateSrv = templateSrv;\n",
" this.ref = getDataSourceRef(instanceSettings);\n",
" }\n",
"\n",
" awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {\n",
" const options = {\n",
" method: 'POST',\n",
" url,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" awsRequest(\n",
" url: string,\n",
" data: MetricRequest,\n",
" headers: Record<string, string> = {}\n",
" ): Observable<FetchResponse<BackendDataSourceResponse>> {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 27
} | import { monacoTypes, Monaco } from '@grafana/ui';
import { SeriesMessage } from '../types';
import { CompletionProvider } from './autocomplete';
describe('CompletionProvider', () => {
it('suggests labels', () => {
const { provider, model } = setup('{}', 1, defaultLabels);
const result = provider.provideCompletionItems(model, {} as monacoTypes.Position);
expect((result! as monacoTypes.languages.CompletionList).suggestions).toEqual([
expect.objectContaining({ label: 'foo', insertText: 'foo' }),
]);
});
it('suggests label names with quotes', () => {
const { provider, model } = setup('{foo=}', 6, defaultLabels);
const result = provider.provideCompletionItems(model, {} as monacoTypes.Position);
expect((result! as monacoTypes.languages.CompletionList).suggestions).toEqual([
expect.objectContaining({ label: 'bar', insertText: '"bar"' }),
]);
});
it('suggests label names without quotes', () => {
const { provider, model } = setup('{foo="}', 7, defaultLabels);
const result = provider.provideCompletionItems(model, {} as monacoTypes.Position);
expect((result! as monacoTypes.languages.CompletionList).suggestions).toEqual([
expect.objectContaining({ label: 'bar', insertText: 'bar' }),
]);
});
it('suggests nothing without labels', () => {
const { provider, model } = setup('{foo="}', 7, []);
const result = provider.provideCompletionItems(model, {} as monacoTypes.Position);
expect((result! as monacoTypes.languages.CompletionList).suggestions).toEqual([]);
});
it('suggests labels on empty input', () => {
const { provider, model } = setup('', 0, defaultLabels);
const result = provider.provideCompletionItems(model, {} as monacoTypes.Position);
expect((result! as monacoTypes.languages.CompletionList).suggestions).toEqual([
expect.objectContaining({ label: 'foo', insertText: '{foo="' }),
]);
});
});
const defaultLabels = [{ labels: [{ name: 'foo', value: 'bar' }] }];
function setup(value: string, offset: number, series?: SeriesMessage) {
const provider = new CompletionProvider();
if (series) {
provider.setSeries(series);
}
const model = makeModel(value, offset);
provider.monaco = {
Range: {
fromPositions() {
return null;
},
},
languages: {
CompletionItemKind: {
Enum: 1,
EnumMember: 2,
},
},
} as unknown as Monaco;
provider.editor = {
getModel() {
return model;
},
} as monacoTypes.editor.IStandaloneCodeEditor;
return { provider, model };
}
function makeModel(value: string, offset: number) {
return {
id: 'test_monaco',
getWordAtPosition() {
return null;
},
getOffsetAt() {
return offset;
},
getValue() {
return value;
},
} as unknown as monacoTypes.editor.ITextModel;
}
| public/app/plugins/datasource/phlare/QueryEditor/autocomplete.test.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017934062634594738,
0.00017675159324426204,
0.000174066168256104,
0.00017660862067714334,
0.0000015332796010625316
]
|
{
"id": 10,
"code_window": [
" constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {\n",
" this.templateSrv = templateSrv;\n",
" this.ref = getDataSourceRef(instanceSettings);\n",
" }\n",
"\n",
" awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {\n",
" const options = {\n",
" method: 'POST',\n",
" url,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" awsRequest(\n",
" url: string,\n",
" data: MetricRequest,\n",
" headers: Record<string, string> = {}\n",
" ): Observable<FetchResponse<BackendDataSourceResponse>> {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 27
} | package migrations
import (
"fmt"
"net/url"
"time"
"xorm.io/xorm"
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/services/datasources"
"github.com/grafana/grafana/pkg/services/sqlstore/migrations/ualert"
"github.com/grafana/grafana/pkg/services/sqlstore/migrator"
"github.com/grafana/grafana/pkg/util"
)
func AddExternalAlertmanagerToDatasourceMigration(mg *migrator.Migrator) {
mg.AddMigration("migrate external alertmanagers to datsourcse", &externalAlertmanagerToDatasources{})
}
type externalAlertmanagerToDatasources struct {
migrator.MigrationBase
}
type AdminConfiguration struct {
OrgID int64 `xorm:"org_id"`
Alertmanagers []string
CreatedAt int64 `xorm:"created_at"`
UpdatedAt int64 `xorm:"updated_at"`
}
func (e externalAlertmanagerToDatasources) SQL(dialect migrator.Dialect) string {
return "migrate external alertmanagers to datasource"
}
func (e externalAlertmanagerToDatasources) Exec(sess *xorm.Session, mg *migrator.Migrator) error {
var results []AdminConfiguration
err := sess.SQL("SELECT org_id, alertmanagers, created_at, updated_at FROM ngalert_configuration").Find(&results)
if err != nil {
return err
}
for _, result := range results {
for _, am := range removeDuplicates(result.Alertmanagers) {
u, err := url.Parse(am)
if err != nil {
return err
}
uri := fmt.Sprintf("%s://%s%s", u.Scheme, u.Host, u.Path)
uid, err := generateNewDatasourceUid(sess, result.OrgID)
if err != nil {
return err
}
ds := &datasources.DataSource{
OrgID: result.OrgID,
Name: fmt.Sprintf("alertmanager-%s", uid),
Type: "alertmanager",
Access: "proxy",
URL: uri,
Created: time.Unix(result.CreatedAt, 0),
Updated: time.Unix(result.UpdatedAt, 0),
UID: uid,
Version: 1,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
"implementation": "prometheus",
}),
SecureJsonData: map[string][]byte{},
}
if u.User != nil {
ds.BasicAuth = true
ds.BasicAuthUser = u.User.Username()
if password, ok := u.User.Password(); ok {
ds.SecureJsonData = ualert.GetEncryptedJsonData(map[string]string{
"basicAuthPassword": password,
})
}
}
rowsAffected, err := sess.Table("data_source").Insert(ds)
if err != nil {
return err
}
if rowsAffected == 0 {
return fmt.Errorf("expected 1 row, got %d", rowsAffected)
}
}
}
return nil
}
func removeDuplicates(strs []string) []string {
var res []string
found := map[string]bool{}
for _, str := range strs {
if found[str] {
continue
}
found[str] = true
res = append(res, str)
}
return res
}
func generateNewDatasourceUid(sess *xorm.Session, orgId int64) (string, error) {
for i := 0; i < 3; i++ {
uid := util.GenerateShortUID()
exists, err := sess.Table("data_source").Where("uid = ? AND org_id = ?", uid, orgId).Exist()
if err != nil {
return "", err
}
if !exists {
return uid, nil
}
}
return "", datasources.ErrDataSourceFailedGenerateUniqueUid
}
| pkg/services/sqlstore/migrations/external_alertmanagers.go | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0001764407061273232,
0.00017144257435575128,
0.0001628916506888345,
0.00017233048856724054,
0.000004023724159196718
]
|
{
"id": 10,
"code_window": [
" constructor(public instanceSettings: DataSourceInstanceSettings<CloudWatchJsonData>, templateSrv: TemplateSrv) {\n",
" this.templateSrv = templateSrv;\n",
" this.ref = getDataSourceRef(instanceSettings);\n",
" }\n",
"\n",
" awsRequest(url: string, data: MetricRequest, headers: Record<string, string> = {}): Observable<TSDBResponse> {\n",
" const options = {\n",
" method: 'POST',\n",
" url,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" awsRequest(\n",
" url: string,\n",
" data: MetricRequest,\n",
" headers: Record<string, string> = {}\n",
" ): Observable<FetchResponse<BackendDataSourceResponse>> {\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 27
} | // ==========================================================================
// FILTER TABLE
// ==========================================================================
// Table
// --------------------------------------------------------------------------
.filter-table * {
box-sizing: border-box;
}
.filter-table {
width: 100%;
border-collapse: separate;
tbody {
tr:nth-child(odd) {
background: $table-bg-odd;
}
}
th {
width: auto;
padding: $space-inset-squish-md;
text-align: left;
line-height: 30px;
height: 30px;
white-space: nowrap;
}
td {
padding: $space-inset-squish-md;
line-height: 30px;
height: 30px;
white-space: nowrap;
&.filter-table__switch-cell {
padding: 0;
border-right: 3px solid $page-bg;
}
}
.link-td {
padding: 0;
line-height: 30px;
height: 30px;
white-space: nowrap;
&.filter-table__switch-cell {
padding: 0;
border-right: 3px solid $page-bg;
}
a {
display: block;
padding: 0px $space-sm;
height: 30px;
}
}
.ellipsis {
display: block;
width: 100%;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.expanded {
border-color: $panel-bg;
}
.expanded > td {
padding-bottom: 0;
}
.filter-table__avatar {
width: 25px;
height: 25px;
border-radius: 50%;
}
&--hover {
tbody tr:hover {
background: $table-bg-hover;
}
}
}
.filter-table__weak-italic {
font-style: italic;
color: $text-color-weak;
}
| public/sass/components/_filter-table.scss | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017977137758862227,
0.0001772658433765173,
0.00017533983918838203,
0.00017713371198624372,
0.0000014993574950494803
]
|
{
"id": 11,
"code_window": [
" headers,\n",
" };\n",
"\n",
" return getBackendSrv()\n",
" .fetch<TSDBResponse>(options)\n",
" .pipe(map((result) => result.data));\n",
" }\n",
"\n",
" convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {\n",
" return Object.entries(dimensions).reduce((result, [key, value]) => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" return getBackendSrv().fetch<BackendDataSourceResponse>(options);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 35
} | import Prism, { Grammar } from 'prismjs';
import { lastValueFrom } from 'rxjs';
import { AbsoluteTimeRange, HistoryItem, LanguageProvider } from '@grafana/data';
import { CompletionItemGroup, SearchFunctionType, Token, TypeaheadInput, TypeaheadOutput } from '@grafana/ui';
import { getTemplateSrv } from 'app/features/templating/template_srv';
import { CloudWatchDatasource } from '../../datasource';
import { CloudWatchQuery, LogGroup, TSDBResponse } from '../../types';
import { interpolateStringArrayUsingSingleOrMultiValuedVariable } from '../../utils/templateVariableUtils';
import syntax, {
AGGREGATION_FUNCTIONS_STATS,
BOOLEAN_FUNCTIONS,
DATETIME_FUNCTIONS,
FIELD_AND_FILTER_FUNCTIONS,
IP_FUNCTIONS,
NUMERIC_OPERATORS,
QUERY_COMMANDS,
STRING_FUNCTIONS,
} from './syntax';
export type CloudWatchHistoryItem = HistoryItem<CloudWatchQuery>;
type TypeaheadContext = {
history?: CloudWatchHistoryItem[];
absoluteRange?: AbsoluteTimeRange;
logGroups?: LogGroup[];
region: string;
};
export class CloudWatchLogsLanguageProvider extends LanguageProvider {
started = false;
declare initialRange: AbsoluteTimeRange;
datasource: CloudWatchDatasource;
constructor(datasource: CloudWatchDatasource, initialValues?: any) {
super();
this.datasource = datasource;
Object.assign(this, initialValues);
}
// Strip syntax chars
cleanText = (s: string) => s.replace(/[()]/g, '').trim();
getSyntax(): Grammar {
return syntax;
}
request = (url: string, params?: any): Promise<TSDBResponse> => {
return lastValueFrom(this.datasource.logsQueryRunner.awsRequest(url, params));
};
start = () => {
if (!this.startTask) {
this.startTask = Promise.resolve().then(() => {
this.started = true;
return [];
});
}
return this.startTask;
};
isStatsQuery(query: string): boolean {
const grammar = this.getSyntax();
const tokens = Prism.tokenize(query, grammar) ?? [];
return !!tokens.find(
(token) =>
typeof token !== 'string' &&
token.content.toString().toLowerCase() === 'stats' &&
token.type === 'query-command'
);
}
/**
* Return suggestions based on input that can be then plugged into a typeahead dropdown.
* Keep this DOM-free for testing
* @param input
* @param context Is optional in types but is required in case we are doing getLabelCompletionItems
* @param context.absoluteRange Required in case we are doing getLabelCompletionItems
* @param context.history Optional used only in getEmptyCompletionItems
*/
async provideCompletionItems(input: TypeaheadInput, context?: TypeaheadContext): Promise<TypeaheadOutput> {
const { value } = input;
// Get tokens
const tokens = value?.data.get('tokens');
if (!tokens || !tokens.length) {
return { suggestions: [] };
}
const curToken: Token = tokens.filter(
(token: any) =>
token.offsets.start <= value!.selection?.start?.offset && token.offsets.end >= value!.selection?.start?.offset
)[0];
const isFirstToken = !curToken.prev;
const prevToken = prevNonWhitespaceToken(curToken);
const isCommandStart = isFirstToken || (!isFirstToken && prevToken?.types.includes('command-separator'));
if (isCommandStart) {
return this.getCommandCompletionItems();
}
if (isInsideFunctionParenthesis(curToken)) {
return await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
}
if (isAfterKeyword('by', curToken)) {
return this.handleKeyword(context);
}
if (prevToken?.types.includes('comparison-operator')) {
return this.handleComparison(context);
}
const commandToken = previousCommandToken(curToken);
if (commandToken) {
return await this.handleCommand(commandToken, curToken, context);
}
return {
suggestions: [],
};
}
private fetchFields = async (logGroups: LogGroup[], region: string): Promise<string[]> => {
const interpolatedLogGroups = interpolateStringArrayUsingSingleOrMultiValuedVariable(
getTemplateSrv(),
logGroups.map((lg) => lg.name),
{},
'text'
);
const results = await Promise.all(
interpolatedLogGroups.map((logGroupName) =>
this.datasource.resources
.getLogGroupFields({ logGroupName, region })
.then((fields) => fields.filter((f) => f).map((f) => f.value.name ?? ''))
)
);
return results.flat();
};
private handleKeyword = async (context?: TypeaheadContext): Promise<TypeaheadOutput> => {
const suggs = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const functionSuggestions: CompletionItemGroup[] = [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: STRING_FUNCTIONS.concat(DATETIME_FUNCTIONS, IP_FUNCTIONS),
},
];
suggs.suggestions.push(...functionSuggestions);
return suggs;
};
private handleCommand = async (
commandToken: Token,
curToken: Token,
context?: TypeaheadContext
): Promise<TypeaheadOutput> => {
const queryCommand = commandToken.content.toLowerCase();
const prevToken = prevNonWhitespaceToken(curToken);
const currentTokenIsFirstArg = prevToken === commandToken;
if (queryCommand === 'sort') {
return this.handleSortCommand(currentTokenIsFirstArg, curToken, context);
}
if (queryCommand === 'parse') {
if (currentTokenIsFirstArg) {
return await this.getFieldCompletionItems(context?.logGroups ?? [], context?.region || 'default');
}
}
const currentTokenIsAfterCommandAndEmpty = isTokenType(commandToken.next, 'whitespace') && !commandToken.next?.next;
const currentTokenIsAfterCommand =
currentTokenIsAfterCommandAndEmpty || nextNonWhitespaceToken(commandToken) === curToken;
const currentTokenIsComma = isTokenType(curToken, 'punctuation', ',');
const currentTokenIsCommaOrAfterComma = currentTokenIsComma || isTokenType(prevToken, 'punctuation', ',');
// We only show suggestions if we are after a command or after a comma which is a field separator
if (!(currentTokenIsAfterCommand || currentTokenIsCommaOrAfterComma)) {
return { suggestions: [] };
}
if (['display', 'fields'].includes(queryCommand)) {
const typeaheadOutput = await this.getFieldCompletionItems(
context?.logGroups ?? [],
context?.region || 'default'
);
typeaheadOutput.suggestions.push(...this.getFieldAndFilterFunctionCompletionItems().suggestions);
return typeaheadOutput;
}
if (queryCommand === 'stats') {
const typeaheadOutput = this.getStatsAggCompletionItems();
if (currentTokenIsComma || currentTokenIsAfterCommandAndEmpty) {
typeaheadOutput?.suggestions.forEach((group) => {
group.skipFilter = true;
});
}
return typeaheadOutput;
}
if (queryCommand === 'filter' && currentTokenIsFirstArg) {
const sugg = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const boolFuncs = this.getBoolFuncCompletionItems();
sugg.suggestions.push(...boolFuncs.suggestions);
return sugg;
}
return { suggestions: [] };
};
private async handleSortCommand(
isFirstArgument: boolean,
curToken: Token,
context?: TypeaheadContext
): Promise<TypeaheadOutput> {
if (isFirstArgument) {
return await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
} else if (isTokenType(prevNonWhitespaceToken(curToken), 'field-name')) {
// suggest sort options
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Sort Order',
items: [
{
label: 'asc',
},
{ label: 'desc' },
],
},
],
};
}
return { suggestions: [] };
}
private handleComparison = async (context?: TypeaheadContext) => {
const fieldsSuggestions = await this.getFieldCompletionItems(context?.logGroups, context?.region || 'default');
const comparisonSuggestions = this.getComparisonCompletionItems();
fieldsSuggestions.suggestions.push(...comparisonSuggestions.suggestions);
return fieldsSuggestions;
};
private getCommandCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [{ searchFunctionType: SearchFunctionType.Prefix, label: 'Commands', items: QUERY_COMMANDS }],
};
};
private getFieldAndFilterFunctionCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{ searchFunctionType: SearchFunctionType.Prefix, label: 'Functions', items: FIELD_AND_FILTER_FUNCTIONS },
],
};
};
private getStatsAggCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{ searchFunctionType: SearchFunctionType.Prefix, label: 'Functions', items: AGGREGATION_FUNCTIONS_STATS },
],
};
};
private getBoolFuncCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: BOOLEAN_FUNCTIONS,
},
],
};
};
private getComparisonCompletionItems = (): TypeaheadOutput => {
return {
suggestions: [
{
searchFunctionType: SearchFunctionType.Prefix,
label: 'Functions',
items: NUMERIC_OPERATORS.concat(BOOLEAN_FUNCTIONS),
},
],
};
};
private getFieldCompletionItems = async (
logGroups: LogGroup[] | undefined,
region: string
): Promise<TypeaheadOutput> => {
if (!logGroups) {
return { suggestions: [] };
}
const fields = await this.fetchFields(logGroups, region);
return {
suggestions: [
{
label: 'Fields',
items: fields.map((field) => ({
label: field,
insertText: field.match(/@?[_a-zA-Z]+[_.0-9a-zA-Z]*/) ? undefined : `\`${field}\``,
})),
},
],
};
};
}
function nextNonWhitespaceToken(token: Token): Token | null {
let curToken = token;
while (curToken.next) {
if (curToken.next.types.includes('whitespace')) {
curToken = curToken.next;
} else {
return curToken.next;
}
}
return null;
}
function prevNonWhitespaceToken(token: Token): Token | null {
let curToken = token;
while (curToken.prev) {
if (isTokenType(curToken.prev, 'whitespace')) {
curToken = curToken.prev;
} else {
return curToken.prev;
}
}
return null;
}
function previousCommandToken(startToken: Token): Token | null {
let thisToken = startToken;
while (!!thisToken.prev) {
thisToken = thisToken.prev;
if (
thisToken.types.includes('query-command') &&
(!thisToken.prev || isTokenType(prevNonWhitespaceToken(thisToken), 'command-separator'))
) {
return thisToken;
}
}
return null;
}
const funcsWithFieldArgs = [
'avg',
'count',
'count_distinct',
'earliest',
'latest',
'sortsFirst',
'sortsLast',
'max',
'min',
'pct',
'stddev',
'ispresent',
'fromMillis',
'toMillis',
'isempty',
'isblank',
'isValidIp',
'isValidIpV4',
'isValidIpV6',
'isIpInSubnet',
'isIpv4InSubnet',
'isIpv6InSubnet',
].map((funcName) => funcName.toLowerCase());
/**
* Returns true if cursor is currently inside a function parenthesis for example `count(|)` or `count(@mess|)` should
* return true.
*/
function isInsideFunctionParenthesis(curToken: Token): boolean {
const prevToken = prevNonWhitespaceToken(curToken);
if (!prevToken) {
return false;
}
const parenthesisToken = curToken.content === '(' ? curToken : prevToken.content === '(' ? prevToken : undefined;
if (parenthesisToken) {
const maybeFunctionToken = prevNonWhitespaceToken(parenthesisToken);
if (maybeFunctionToken) {
return (
funcsWithFieldArgs.includes(maybeFunctionToken.content.toLowerCase()) &&
maybeFunctionToken.types.includes('function')
);
}
}
return false;
}
function isAfterKeyword(keyword: string, token: Token): boolean {
const maybeKeyword = getPreviousTokenExcluding(token, [
'whitespace',
'function',
'punctuation',
'field-name',
'number',
]);
if (isTokenType(maybeKeyword, 'keyword', 'by')) {
const prev = getPreviousTokenExcluding(token, ['whitespace']);
if (prev === maybeKeyword || isTokenType(prev, 'punctuation', ',')) {
return true;
}
}
return false;
}
function isTokenType(token: Token | undefined | null, type: string, content?: string): boolean {
if (!token?.types.includes(type)) {
return false;
}
if (content) {
if (token?.content.toLowerCase() !== content) {
return false;
}
}
return true;
}
type TokenDef = string | { type: string; value: string };
function getPreviousTokenExcluding(token: Token, exclude: TokenDef[]): Token | undefined | null {
let curToken = token.prev;
main: while (curToken) {
for (const item of exclude) {
if (typeof item === 'string') {
if (curToken.types.includes(item)) {
curToken = curToken.prev;
continue main;
}
} else {
if (curToken.types.includes(item.type) && curToken.content.toLowerCase() === item.value) {
curToken = curToken.prev;
continue main;
}
}
}
break;
}
return curToken;
}
| public/app/plugins/datasource/cloudwatch/language/cloudwatch-logs/CloudWatchLogsLanguageProvider.ts | 1 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.0001902001240523532,
0.000172111060237512,
0.00016497795877512544,
0.00017178042617160827,
0.000004001612978754565
]
|
{
"id": 11,
"code_window": [
" headers,\n",
" };\n",
"\n",
" return getBackendSrv()\n",
" .fetch<TSDBResponse>(options)\n",
" .pipe(map((result) => result.data));\n",
" }\n",
"\n",
" convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {\n",
" return Object.entries(dimensions).reduce((result, [key, value]) => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" return getBackendSrv().fetch<BackendDataSourceResponse>(options);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 35
} | # Currently recommended practices
We occasionally identify patterns that are either useful or harmful that
we'll want to introduce or remove from the codebase. When the complexity
or importance of introducing or removing such a pattern is sufficiently
high, we'll document it here to provide an addressable local
'currently recommended practice'. By collecting these practices in a
single place, we're able to reference them and make it easier to have a
shared understanding of how to write idiomatic code for the Grafana
backend.
Large-scale refactoring based on a new recommended practice is a
delicate matter, and most of the time it's better to introduce the new
way incrementally over multiple releases and over time to balance the
want to introduce new useful patterns and the need to keep Grafana
stable. It's also easier to review and revert smaller chunks of changes,
reducing the risk of complications.
| State | Description |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| Proposed | The practice has been proposed and been positively received by the Grafana team. Following the proposal is a discretionary choice for developers. |
| Ongoing, active | The practice is actively being worked on. New code should adhere to the practice where at all possible. |
| Ongoing, passive | There is no immediate active work on refactoring old code. New code should adhere to the practice where at all possible. |
| Completed | The work has been done and there is no, or negligible, legacy code left that need refactoring. New code must adhere to the practice. |
| Abandoned | The practice has no longer any active ongoing work and new code don't need to comply with the practice described. |
## 1 - Idiomatic Grafana code should be idiomatic Go code
**Status:** Ongoing, passive.
It'll be easier for contributors to start contributing to Grafana if our
code is easily understandable. When there isn't a more specific Grafana
recommended practice, we recommend following the practices as put forth
by the Go project for development of Go code or the Go compiler itself
when applicable.
The first resource we recommend everyone developing Grafana's backend to
skim is "[Effective Go](https://golang.org/doc/effective_go.html)",
which isn't updated to reflect more recent changes since Go was
initially released but remain a good source for understanding the
general differences between Go and other languages.
Secondly, the guidelines for [Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments)
for the Go compiler can mostly be applied directly to the Grafana
codebase. There are idiosyncrasies in Grafana such as interfaces living
closer to its declaration than to its users for services and don't
enforce documentation of public declarations (prioritize high coverage
of documentation aimed at end-users over documenting internals in the
backend).
- [Effective Go](https://golang.org/doc/effective_go.html)
- [Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments)
## 100 - Global state
**State:** Ongoing, passive.
Global state makes testing and debugging software harder, and it's something we want to avoid when possible. Unfortunately, there is quite a lot of global state in Grafana.
We want to migrate away from this by using
[Wire](https://github.com/google/wire) and dependency injection to pack
## 101 - Limit the use of the init() function
**State:** Ongoing, passive.
Only use the init() function to register services/implementations.
## 102 - Settings refactoring
**State:** Ongoing, passive.
The plan is to move all settings to from package level vars in settings package to the [setting.Cfg](https://github.com/grafana/grafana/blob/df917663e6f358a076ed3daa9b199412e95c11f4/pkg/setting/setting.go#L210) struct. To access the settings, services and components can inject this setting.Cfg struct:
- [Cfg struct](https://github.com/grafana/grafana/blob/df917663e6f358a076ed3daa9b199412e95c11f4/pkg/setting/setting.go#L210)
- [Injection example](https://github.com/grafana/grafana/blob/c9773e55b234b7637ea97b671161cd856a1d3d69/pkg/services/cleanup/cleanup.go#L34)
## 103 - Reduce the use of GoConvey
**State:** Completed.
We want to migrate away from using GoConvey. Instead, we want to use
stdlib testing with [testify](https://github.com/stretchr/testify),
because it's the most common approach in the Go community, and we think
it will be easier for new contributors. Read more about how we want to
write tests in the [style guide](/contribute/backend/style-guide.md).
## 104 - Refactor SqlStore
**State:** Completed.
The `sqlstore` handlers all use a global xorm engine variable. Refactor them to use the `SqlStore` instance.
## 105 - Avoid global HTTP handler functions
**State:** Ongoing, passive.
Refactor HTTP handlers so that the handler methods are on the HttpServer instance or a more detailed handler struct. E.g (AuthHandler). This ensures they get access to HttpServer service dependencies (and Cfg object) and can avoid global state.
## 106 - Date comparison
**State:** Ongoing, passive.
Store newly introduced date columns in the database as epoch based
integers (i.e. unix timestamps) if they require date comparison. This
permits a unified approach for comparing dates against all the supported
databases instead of handling dates differently for each database. Also,
by comparing epoch based integers, we no longer need error pruning
transformations to and from other time zones.
## 107 - Avoid use of the simplejson package
**State:** Ongoing, passive
Use of the `simplejson` package (`pkg/components/simplejson`) in place
of types (Go structs) results in code that is difficult to maintain.
Instead, create types for objects and use the Go standard library's
[`encoding/json`](https://golang.org/pkg/encoding/json/) package.
## 108 - Provisionable\*
**State:** Abandoned: Grafana's file based refactoring is limited to work natively only on on-premise installations of Grafana. We're looking at enhancing the use of the API to enable provisioning for all Grafana instances.
All new features that require state should be possible to configure using config files. For example:
- [Data sources](https://github.com/grafana/grafana/tree/main/pkg/services/provisioning/datasources)
- [Alert notifiers](https://github.com/grafana/grafana/tree/main/pkg/services/provisioning/notifiers)
- [Dashboards](https://github.com/grafana/grafana/tree/main/pkg/services/provisioning/dashboards)
Today it's only possible to provision data sources and dashboards but this is something we want to support all over Grafana.
### 109 - Use context.Context "everywhere"
**State:** Completed.
The package [context](https://golang.org/pkg/context/) should be used
and propagated through all the layers of the code. For example the
`context.Context` of an incoming API request should be propagated to any
other layers being used such as the bus, service and database layers.
Utility functions/methods normally doesn't need `context.Context`.
To follow Go best practices, any function/method that receives a
[`context.Context` argument should receive it as its first parameter](https://github.com/golang/go/wiki/CodeReviewComments#contexts).
To be able to solve certain problems and/or implement and support
certain features making sure that `context.Context` is passed down
through all layers of the code is vital. Being able to provide
contextual information for the full life-cycle of an API request allows
us to use contextual logging, provide contextual information about the
authenticated user, create multiple spans for a distributed trace of
service calls and database queries etc.
Code should use `context.TODO` when it's unclear which Context to use,
or it is not yet available (because the surrounding function has not yet
been extended to accept a `context.Context` argument).
More details in [Services](/contribute/backend/services.md), [Communication](/contribute/backend/communication.md) and [Database](/contribute/backend/database.md).
[Original design doc](https://docs.google.com/document/d/1ebUhUVXU8FlShezsN-C64T0dOoo-DaC9_r-c8gB2XEU/edit#).
## 110 - Move API error handling to service layer
**State:** Ongoing, passive.
All errors returned from Grafana's services should carry a status and
the information necessary to provide a structured end-user facing
message that the frontend can display and internationalize for
end-users.
More details in [Errors](/contribute/backend/errors.md).
| contribute/backend/recommended-practices.md | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017347100947517902,
0.0001676158281043172,
0.00016221818805206567,
0.0001670868368819356,
0.000003926818862964865
]
|
{
"id": 11,
"code_window": [
" headers,\n",
" };\n",
"\n",
" return getBackendSrv()\n",
" .fetch<TSDBResponse>(options)\n",
" .pipe(map((result) => result.data));\n",
" }\n",
"\n",
" convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {\n",
" return Object.entries(dimensions).reduce((result, [key, value]) => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" return getBackendSrv().fetch<BackendDataSourceResponse>(options);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 35
} | import { isPromAlertingRuleState, PromAlertingRuleState, PromRuleType } from '../../../../types/unified-alerting-dto';
import { getRuleHealth, isPromRuleType } from '../utils/rules';
import * as terms from './search.terms';
import {
applyFiltersToQuery,
FilterExpr,
FilterSupportedTerm,
parseQueryToFilter,
QueryFilterMapper,
} from './searchParser';
export interface RulesFilter {
freeFormWords: string[];
namespace?: string;
groupName?: string;
ruleName?: string;
ruleState?: PromAlertingRuleState;
ruleType?: PromRuleType;
dataSourceNames: string[];
labels: string[];
ruleHealth?: RuleHealth;
}
const filterSupportedTerms: FilterSupportedTerm[] = [
FilterSupportedTerm.dataSource,
FilterSupportedTerm.nameSpace,
FilterSupportedTerm.label,
FilterSupportedTerm.group,
FilterSupportedTerm.rule,
FilterSupportedTerm.state,
FilterSupportedTerm.type,
FilterSupportedTerm.health,
];
export enum RuleHealth {
Ok = 'ok',
Error = 'error',
NoData = 'nodata',
Unknown = 'unknown',
}
// Define how to map parsed tokens into the filter object
export function getSearchFilterFromQuery(query: string): RulesFilter {
const filter: RulesFilter = { labels: [], freeFormWords: [], dataSourceNames: [] };
const tokenToFilterMap: QueryFilterMapper = {
[terms.DataSourceToken]: (value) => filter.dataSourceNames.push(value),
[terms.NameSpaceToken]: (value) => (filter.namespace = value),
[terms.GroupToken]: (value) => (filter.groupName = value),
[terms.RuleToken]: (value) => (filter.ruleName = value),
[terms.LabelToken]: (value) => filter.labels.push(value),
[terms.StateToken]: (value) => (filter.ruleState = parseStateToken(value)),
[terms.TypeToken]: (value) => (isPromRuleType(value) ? (filter.ruleType = value) : undefined),
[terms.HealthToken]: (value) => (filter.ruleHealth = getRuleHealth(value)),
[terms.FreeFormExpression]: (value) => filter.freeFormWords.push(value),
};
parseQueryToFilter(query, filterSupportedTerms, tokenToFilterMap);
return filter;
}
// Reverse of the previous function
// Describes how to map the object into an array of tokens and values
export function applySearchFilterToQuery(query: string, filter: RulesFilter): string {
const filterStateArray: FilterExpr[] = [];
// Convert filter object into an array
// It allows to pick filters from the array in the same order as they were applied in the original query
if (filter.dataSourceNames) {
filterStateArray.push(...filter.dataSourceNames.map((t) => ({ type: terms.DataSourceToken, value: t })));
}
if (filter.namespace) {
filterStateArray.push({ type: terms.NameSpaceToken, value: filter.namespace });
}
if (filter.groupName) {
filterStateArray.push({ type: terms.GroupToken, value: filter.groupName });
}
if (filter.ruleName) {
filterStateArray.push({ type: terms.RuleToken, value: filter.ruleName });
}
if (filter.ruleState) {
filterStateArray.push({ type: terms.StateToken, value: filter.ruleState });
}
if (filter.ruleType) {
filterStateArray.push({ type: terms.TypeToken, value: filter.ruleType });
}
if (filter.ruleHealth) {
filterStateArray.push({ type: terms.HealthToken, value: filter.ruleHealth });
}
if (filter.labels) {
filterStateArray.push(...filter.labels.map((l) => ({ type: terms.LabelToken, value: l })));
}
if (filter.freeFormWords) {
filterStateArray.push(...filter.freeFormWords.map((word) => ({ type: terms.FreeFormExpression, value: word })));
}
return applyFiltersToQuery(query, filterSupportedTerms, filterStateArray);
}
function parseStateToken(value: string): PromAlertingRuleState | undefined {
if (value === 'normal') {
return PromAlertingRuleState.Inactive;
}
if (isPromAlertingRuleState(value)) {
return value;
}
return;
}
| public/app/features/alerting/unified/search/rulesSearchParser.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017821606888901442,
0.000171786654391326,
0.00016508872795384377,
0.00017181580187752843,
0.000004271856141713215
]
|
{
"id": 11,
"code_window": [
" headers,\n",
" };\n",
"\n",
" return getBackendSrv()\n",
" .fetch<TSDBResponse>(options)\n",
" .pipe(map((result) => result.data));\n",
" }\n",
"\n",
" convertDimensionFormat(dimensions: Dimensions, scopedVars: ScopedVars): Dimensions {\n",
" return Object.entries(dimensions).reduce((result, [key, value]) => {\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" return getBackendSrv().fetch<BackendDataSourceResponse>(options);\n"
],
"file_path": "public/app/plugins/datasource/cloudwatch/query-runner/CloudWatchRequest.ts",
"type": "replace",
"edit_start_line_idx": 35
} | import { DataSourceSettings } from '@grafana/data';
import { ElasticsearchOptions } from '../types';
import { defaultMaxConcurrentShardRequests } from './ElasticDetails';
export const coerceOptions = (
options: DataSourceSettings<ElasticsearchOptions, {}>
): DataSourceSettings<ElasticsearchOptions, {}> => {
return {
...options,
jsonData: {
...options.jsonData,
timeField: options.jsonData.timeField || '@timestamp',
maxConcurrentShardRequests: options.jsonData.maxConcurrentShardRequests || defaultMaxConcurrentShardRequests(),
logMessageField: options.jsonData.logMessageField || '',
logLevelField: options.jsonData.logLevelField || '',
includeFrozen: options.jsonData.includeFrozen ?? false,
},
};
};
export const isValidOptions = (options: DataSourceSettings<ElasticsearchOptions, {}>): boolean => {
return (
// timeField should not be empty or nullish
!!options.jsonData.timeField &&
// maxConcurrentShardRequests should be a number AND greater than 0
!!options.jsonData.maxConcurrentShardRequests &&
// message & level fields should be defined
options.jsonData.logMessageField !== undefined &&
options.jsonData.logLevelField !== undefined
);
};
| public/app/plugins/datasource/elasticsearch/configuration/utils.ts | 0 | https://github.com/grafana/grafana/commit/96453c6e69caa37488cc44c844a754eaff56eea2 | [
0.00017287804803345352,
0.0001693081430858001,
0.00016554917965549976,
0.00016940267232712358,
0.0000031869874419498956
]
|
{
"id": 0,
"code_window": [
"// @ts-ignore\n",
"import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'\n",
"\n",
"// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved\n",
"const LayoutLoader = defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: String,\n",
" ...process.dev ? { hasTransition: Boolean } : {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'LayoutLoader',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 14
} | import { computed, defineComponent, h, provide, reactive, onMounted, nextTick, Suspense, Transition } from 'vue'
import type { DefineComponent, VNode, KeepAliveProps, TransitionProps } from 'vue'
import { RouterView } from 'vue-router'
import { defu } from 'defu'
import type { RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteLocation } from 'vue-router'
import type { RouterViewSlotProps } from './utils'
import { generateRouteKey, wrapInKeepAlive } from './utils'
import { useNuxtApp } from '#app'
import { _wrapIf } from '#app/components/utils'
// @ts-ignore
import { appPageTransition as defaultPageTransition, appKeepalive as defaultKeepaliveConfig } from '#build/nuxt.config.mjs'
export default defineComponent({
name: 'NuxtPage',
inheritAttrs: false,
props: {
name: {
type: String
},
transition: {
type: [Boolean, Object] as any as () => boolean | TransitionProps,
default: undefined
},
keepalive: {
type: [Boolean, Object] as any as () => boolean | KeepAliveProps,
default: undefined
},
route: {
type: Object as () => RouteLocationNormalized
},
pageKey: {
type: [Function, String] as unknown as () => string | ((route: RouteLocationNormalizedLoaded) => string),
default: null
}
},
setup (props, { attrs }) {
const nuxtApp = useNuxtApp()
return () => {
return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
default: (routeProps: RouterViewSlotProps) => {
if (!routeProps.Component) { return }
const key = generateRouteKey(routeProps, props.pageKey)
const done = nuxtApp.deferHydration()
const hasTransition = !!(props.transition ?? routeProps.route.meta.pageTransition ?? defaultPageTransition)
const transitionProps = hasTransition && _mergeTransitionProps([
props.transition,
routeProps.route.meta.pageTransition,
defaultPageTransition,
{ onAfterLeave: () => { nuxtApp.callHook('page:transition:finish', routeProps.Component) } }
].filter(Boolean))
return _wrapIf(Transition, hasTransition && transitionProps,
wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {
onPending: () => nuxtApp.callHook('page:start', routeProps.Component),
onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }
}, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })
)).default()
}
})
}
}
}) as DefineComponent<{
name?: string
transition?: boolean | TransitionProps
keepalive?: boolean | KeepAliveProps
route?: RouteLocationNormalized
pageKey?: string | ((route: RouteLocationNormalizedLoaded) => string)
[key: string]: any
}>
function _toArray (val: any) {
return Array.isArray(val) ? val : (val ? [val] : [])
}
function _mergeTransitionProps (routeProps: TransitionProps[]): TransitionProps {
const _props: TransitionProps[] = routeProps.map(prop => ({
...prop,
onAfterLeave: _toArray(prop.onAfterLeave)
}))
// @ts-ignore
return defu(..._props)
}
const Component = defineComponent({
// TODO: Type props
// eslint-disable-next-line vue/require-prop-types
props: ['routeProps', 'pageKey', 'hasTransition'],
setup (props) {
// Prevent reactivity when the page will be rerendered in a different suspense fork
// eslint-disable-next-line vue/no-setup-props-destructure
const previousKey = props.pageKey
// eslint-disable-next-line vue/no-setup-props-destructure
const previousRoute = props.routeProps.route
// Provide a reactive route within the page
const route = {} as RouteLocation
for (const key in props.routeProps.route) {
(route as any)[key] = computed(() => previousKey === props.pageKey ? props.routeProps.route[key] : previousRoute[key])
}
provide('_route', reactive(route))
let vnode: VNode
if (process.dev && process.client && props.hasTransition) {
onMounted(() => {
nextTick(() => {
if (['#comment', '#text'].includes(vnode?.el?.nodeName)) {
const filename = (vnode?.type as any).__file
console.warn(`[nuxt] \`${filename}\` does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
return () => {
if (process.dev && process.client) {
vnode = h(props.routeProps.Component)
return vnode
}
return h(props.routeProps.Component)
}
}
})
| packages/nuxt/src/pages/runtime/page.ts | 1 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.003976554609835148,
0.0009324749116785824,
0.0001638178073335439,
0.0002530402853153646,
0.0012724190019071102
]
|
{
"id": 0,
"code_window": [
"// @ts-ignore\n",
"import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'\n",
"\n",
"// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved\n",
"const LayoutLoader = defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: String,\n",
" ...process.dev ? { hasTransition: Boolean } : {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'LayoutLoader',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 14
} | <?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 26.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
width="1000px" height="128.5px" viewBox="0 0 1000 128.5" enable-background="new 0 0 1000 128.5" xml:space="preserve">
<path fill="#FAFAFA" d="M451.2,1.2c-2.8,4.2-21.9,29.8-33.5,43.9V1.2h-25.3c0,0-1.4,33-1.2,47.9c0.3,28.6,0.9,76.4,0.9,76.4h25.6
V81.9l8.1-9.5c10.2,19.5,28.6,53,28.6,53h29c0,0-29.3-57.6-37.2-73.9c7.4-9.3,23.2-30,37.2-50.6L451.2,1.2z M0,42.1
c0.3,29,1.2,83.6,1.2,83.6h26.7V72.4c16.3-0.5,49-1.9,49-1.9V43.7h-49V29.8l55.3-2.6V0.3L1.9,1C1.9,1-0.2,26.8,0,42.1z M358,1h-26.3
l1.6,84.1L279.7,1h-24.9c0,0-1.6,32.3-1.4,47.4c0.5,29,1.1,77.1,1.1,77.1h26.3L278.6,48l51.3,77.4h27.7c0,0,1.6-33.2,1.4-48.3
C358.5,48.2,358,1,358,1z M195,1c0,0,0.7,44.8,0.7,64.6c0,27-11.8,34.2-27.4,34.2c-15.6,0-27.2-7.2-27.2-34.2
c0-19.8,0.7-64.6,0.7-64.6c0-0.2-27.9,0-27.9,0s-1.6,42.1-1.6,64.6c0,50.7,25.1,62.2,56,62.2c30.9,0,56.2-11.4,56.2-62.2
C224.4,43.1,223,1,223,1S195,0.8,195,1z M602.7,2.1h-26l-1.6,45.8h-41.3V1.8h-27.4c0,0-1.8,32.3-1.6,47.2
c0.5,28.8,1.2,76.7,1.2,76.7h25.8l1.6-49.2h41.2v49.7h27.6c0,0,1.6-33.5,1.4-48.5C603.2,49,602.7,2.1,602.7,2.1z M947.2,48.3
c-10.9,0-21.1,0-21.1-10.4c0-10.4,10.2-10.4,21.1-10.4c9.3,0,18.1,0.7,20.5,12.6l27.7-1.4C992.3,7.4,972.4,0,947.2,0
c-27.6,0-48.5,8.6-48.5,37.9c0,29.5,20.9,38.1,48.5,38.1c12.8,0,24.8,0.4,24.8,11.9c0,11.8-11.9,12.1-24.8,12.1
c-11.2,0-21.8-0.4-24.2-14.9l-28.2,1.2c3,34.4,24.8,42.1,52.5,42.1c30.2,0,52.8-9.7,52.8-40.6C1000,57.2,977.4,48.3,947.2,48.3z
M840.9,1.8c0,0,0.7,44.8,0.7,64.6c0,27-11.8,34.2-27.4,34.2c-15.6,0-27.2-7.2-27.2-34.2c0-19.8,0.7-64.6,0.7-64.6
c0-0.2-27.9,0-27.9,0s-1.6,42.1-1.6,64.6c0,50.7,25.1,62.1,56,62.1c30.9,0,56.2-11.4,56.2-62.1c0-22.5-1.4-64.6-1.4-64.6
S840.9,1.6,840.9,1.8z M692.8,1.8h-20.2c-3.9,0-44.9,117.8-44.9,124.5h28.6l9.6-28.6h33.3l9.5,28.6h28.3
C737.1,119.6,697,1.8,692.8,1.8z M672.8,73c0,0,9.1-29.8,9.5-30.5h0.5l10,30.5H672.8z"/>
</svg>
| docs/public/assets/support/agencies/full/dark/funkhaus.svg | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017437052156310529,
0.00016987969866022468,
0.0001639228139538318,
0.00017134576046373695,
0.0000043894306145375594
]
|
{
"id": 0,
"code_window": [
"// @ts-ignore\n",
"import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'\n",
"\n",
"// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved\n",
"const LayoutLoader = defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: String,\n",
" ...process.dev ? { hasTransition: Boolean } : {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'LayoutLoader',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 14
} | import type { AppConfig } from '@nuxt/schema'
import { reactive } from 'vue'
import { useNuxtApp } from './nuxt'
// @ts-ignore
import __appConfig from '#build/app.config.mjs'
type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? { [P in keyof T]?: DeepPartial<T[P]> } : T
// Workaround for vite HMR with virtual modules
export const _getAppConfig = () => __appConfig as AppConfig
function deepDelete (obj: any, newObj: any) {
for (const key in obj) {
const val = newObj[key]
if (!(key in newObj)) {
delete (obj as any)[key]
}
if (val !== null && typeof val === 'object') {
deepDelete(obj[key], newObj[key])
}
}
}
function deepAssign (obj: any, newObj: any) {
for (const key in newObj) {
const val = newObj[key]
if (val !== null && typeof val === 'object') {
obj[key] = obj[key] || {}
deepAssign(obj[key], val)
} else {
obj[key] = val
}
}
}
export function useAppConfig (): AppConfig {
const nuxtApp = useNuxtApp()
if (!nuxtApp._appConfig) {
nuxtApp._appConfig = reactive(__appConfig) as AppConfig
}
return nuxtApp._appConfig
}
/**
* Deep assign the current appConfig with the new one.
*
* Will preserve existing properties.
*/
export function updateAppConfig (appConfig: DeepPartial<AppConfig>) {
const _appConfig = useAppConfig()
deepAssign(_appConfig, appConfig)
}
// HMR Support
if (process.dev) {
function applyHMR (newConfig: AppConfig) {
const appConfig = useAppConfig()
if (newConfig && appConfig) {
deepAssign(appConfig, newConfig)
deepDelete(appConfig, newConfig)
}
}
// Vite
if (import.meta.hot) {
import.meta.hot.accept((newModule) => {
const newConfig = newModule._getAppConfig()
applyHMR(newConfig)
})
}
// webpack
if (import.meta.webpackHot) {
import.meta.webpackHot.accept('#build/app.config.mjs', () => {
applyHMR(__appConfig)
})
}
}
| packages/nuxt/src/app/config.ts | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00045932538341730833,
0.00020985733135603368,
0.00016270414926111698,
0.00016985644469968975,
0.00009528639202471823
]
|
{
"id": 0,
"code_window": [
"// @ts-ignore\n",
"import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'\n",
"\n",
"// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved\n",
"const LayoutLoader = defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: String,\n",
" ...process.dev ? { hasTransition: Boolean } : {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'LayoutLoader',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 14
} | {
"name": "example-components",
"private": true,
"scripts": {
"build": "nuxi build",
"dev": "nuxi dev",
"start": "nuxi preview"
},
"devDependencies": {
"@nuxt/ui": "^0.3.3",
"nuxt": "^3.0.0"
}
}
| examples/auto-imports/components/package.json | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00016962879453785717,
0.000169421051396057,
0.00016921330825425684,
0.000169421051396057,
2.0774314180016518e-7
]
|
{
"id": 1,
"code_window": [
" }\n",
" }\n",
"})\n",
"export default defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: {\n",
" type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,\n",
" default: null\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'NuxtLayout',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 44
} | import type { Ref, VNode } from 'vue'
import { computed, defineComponent, h, inject, nextTick, onMounted, Transition, unref } from 'vue'
import type { RouteLocationNormalizedLoaded } from 'vue-router'
import { _wrapIf } from './utils'
import { useRoute } from '#app'
// @ts-ignore
import { useRoute as useVueRouterRoute } from '#build/pages'
// @ts-ignore
import layouts from '#build/layouts'
// @ts-ignore
import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'
// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved
const LayoutLoader = defineComponent({
inheritAttrs: false,
props: {
name: String,
...process.dev ? { hasTransition: Boolean } : {}
},
async setup (props, context) {
let vnode: VNode
if (process.dev && process.client) {
onMounted(() => {
nextTick(() => {
if (props.name && ['#comment', '#text'].includes(vnode?.el?.nodeName)) {
console.warn(`[nuxt] \`${props.name}\` layout does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
const LayoutComponent = await layouts[props.name]().then((r: any) => r.default || r)
return () => {
if (process.dev && process.client && props.hasTransition) {
vnode = h(LayoutComponent, context.attrs, context.slots)
return vnode
}
return h(LayoutComponent, context.attrs, context.slots)
}
}
})
export default defineComponent({
inheritAttrs: false,
props: {
name: {
type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,
default: null
}
},
setup (props, context) {
// Need to ensure (if we are not a child of `<NuxtPage>`) that we use synchronous route (not deferred)
const injectedRoute = inject('_route') as RouteLocationNormalizedLoaded
const route = injectedRoute === useRoute() ? useVueRouterRoute() : injectedRoute
const layout = computed(() => unref(props.name) ?? route.meta.layout as string ?? 'default')
let vnode: VNode
let _layout: string | false
if (process.dev && process.client) {
onMounted(() => {
nextTick(() => {
if (_layout && _layout in layouts && ['#comment', '#text'].includes(vnode?.el?.nodeName)) {
console.warn(`[nuxt] \`${_layout}\` layout does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
return () => {
const hasLayout = layout.value && layout.value in layouts
if (process.dev && layout.value && !hasLayout && layout.value !== 'default') {
console.warn(`Invalid layout \`${layout.value}\` selected.`)
}
const transitionProps = route.meta.layoutTransition ?? defaultLayoutTransition
// We avoid rendering layout transition if there is no layout to render
return _wrapIf(Transition, hasLayout && transitionProps, {
default: () => _wrapIf(LayoutLoader, hasLayout && {
key: layout.value,
name: layout.value,
...(process.dev ? { hasTransition: !!transitionProps } : {}),
...context.attrs
}, context.slots).default()
}).default()
}
}
})
| packages/nuxt/src/app/components/layout.ts | 1 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.9984020590782166,
0.22706317901611328,
0.00017017911886796355,
0.0011480526300147176,
0.4115982949733734
]
|
{
"id": 1,
"code_window": [
" }\n",
" }\n",
"})\n",
"export default defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: {\n",
" type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,\n",
" default: null\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'NuxtLayout',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 44
} | ---
toc: false
---
# useHead
This example shows how to use useHead and Nuxt built-in components to bind meta data to the head of the page.
::ReadMore{link="/docs/api/composables/use-head"}
::
::ReadMore{link="/docs/getting-started/seo-meta"}
::
::sandbox{repo="nuxt/framework" branch="main" dir="examples/composables/use-head" file="app.vue"}
::
| docs/content/1.docs/4.examples/3.composables/use-head.md | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017183381714858115,
0.00016768136993050575,
0.00016352892271243036,
0.00016768136993050575,
0.000004152447218075395
]
|
{
"id": 1,
"code_window": [
" }\n",
" }\n",
"})\n",
"export default defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: {\n",
" type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,\n",
" default: null\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'NuxtLayout',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 44
} | ---
title: Solutions
description: Find experts near you to help you to build and enhance your project.
image: '/socials/support.jpg'
---
::page-hero
---
image:
path: '/assets/support/solutions/hero'
format: 'webp'
height: '216'
width: '400'
---
#title
Nuxt Support
#description
Discover the different support offers to answer your questions, get an audit, consulting or build your next idea.
::
::support-section
---
image:
path: 'agency'
width: '73'
height: '81'
format: 'webp'
to: '/support/agencies'
---
#title
Official Agency partners
#description
The agency Partners are a network of trusted agencies from all over the world that can cover every expertise that you may be looking for.
They have been working with Nuxt for years and have dozens of amazing references to showcase their capabilities. <br /><br />
Consult our agency partner catalog and find an agency near you with the right set of skills! <br /><br />
If you have any question, we will gladly help you refine your needs and help you select the relevant partner for you.
#link
[Look for an agency]{ .text-lg .font-semibold }
::
::support-section
---
image:
path: 'experts'
width: '73'
height: '81'
format: 'webp'
---
#title
Nuxt Experts
#description
The Nuxt Expert Network is a group of experienced freelance developers with an expertise in web development with Vue & Nuxt, carefully selected by NuxtLabs.
Their capabilities have been officially certified by the NuxtLabs team during a 3 steps certification process.
<br /> <br />
They act as an external workforce for Nuxtlabs and are qualified to take on any consulting mission on behalf of Nuxtlabs, such as:
#extra
::list{type="success" icon="heroicons-solid:check-circle"}
- Identify and solve your pain points
- Set your project on the right track with best practices
- Improve your website performance
- Provide custom solutions or integrations
::
[Contact us at [[email protected]]{ .text-green-400 } for a quote.]{ .text-lg .font-semibold }
::
::support-section
---
image:
path: 'community'
width: '73'
height: '81'
format: 'webp'
---
#title
Community Support
#description
Our active community is comprised of more than 2000 contributors. Asking your questions on our GitHub discussion board is a free and efficient way to ensure that you find solutions to your problems.
#list
::support-community-list
---
icon: github-discussion
---
#title
GitHub discussion
#description
We first recommend looking for your question on the [discussion board](https://github.com/nuxt/framework/discussions){ .font-semibold .text-green-400 }. Feel free to create a post if you can't find the answer.
::
::support-community-list
---
icon: discord-server
---
#title
Discord server
#description
Our [Discord server](https://discord.com/invite/nuxt-473401852243869706){ .font-semibold .text-green-400 } is also a good place to have real time exchanges with members of the community.
::
::support-community-list
---
icon: other-platform
---
#title
Other Platforms
#description
If none of the solutions above work for you, you can also try the [Nuxt subreddit](https://www.reddit.com/r/Nuxt/){ .font-semibold .text-green-400 } or [Stack Overflow.](https://stackoverflow.com/questions/tagged/nuxt.js?tab=Newest){ .font-semibold .text-green-400 }
::
::
| docs/content/4.support/1.solutions.md | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.0001732552918838337,
0.00016959047934506088,
0.00016320229042321444,
0.00017017572827171534,
0.000002682209014892578
]
|
{
"id": 1,
"code_window": [
" }\n",
" }\n",
"})\n",
"export default defineComponent({\n",
" inheritAttrs: false,\n",
" props: {\n",
" name: {\n",
" type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,\n",
" default: null\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'NuxtLayout',\n"
],
"file_path": "packages/nuxt/src/app/components/layout.ts",
"type": "add",
"edit_start_line_idx": 44
} | <svg fill="none" height="896" viewBox="0 0 1420 896" width="1420" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><clipPath id="a"><rect height="416" rx="6" width="352" x="1004.43" y="336.417"/></clipPath><clipPath id="b"><rect height="416" rx="6" width="352" x="63" y="336"/></clipPath><clipPath id="c"><rect height="416" rx="6" width="352" x="534" y="336"/></clipPath><rect fill="#fcfcfd" height="213.045" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="62" y="77.5825"/><path d="m104.382 159v-16.406h-5.4337v-1.794h13.0517v1.794h-5.434v16.406zm10.155 0v-18.72h2.184v8.034c.433-.797 1.049-1.413 1.846-1.846.797-.451 1.664-.676 2.6-.676 1.491 0 2.687.468 3.588 1.404.901.919 1.352 2.34 1.352 4.264v7.54h-2.158v-7.306c0-2.687-1.083-4.03-3.25-4.03-1.127 0-2.071.407-2.834 1.222-.763.797-1.144 1.941-1.144 3.432v6.682zm20.677.312c-1.231 0-2.323-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.537-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21s.728 1.907.728 2.964c0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.283.494 1.976.494.901 0 1.655-.208 2.262-.624s1.049-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73s-1.664-.988-2.756-.988zm16.588 11.362v-11.05h-1.95v-1.846h1.95v-2.236c0-1.248.312-2.158.936-2.73s1.534-.858 2.73-.858h1.3v1.872h-.962c-.659 0-1.127.139-1.404.416-.278.26-.416.711-.416 1.352v2.184h3.172v1.846h-3.172v11.05zm12.662.312c-1.525 0-2.739-.459-3.64-1.378-.901-.936-1.352-2.366-1.352-4.29v-7.54h2.184v7.306c0 2.687 1.101 4.03 3.302 4.03 1.127 0 2.054-.399 2.782-1.196.745-.815 1.118-1.967 1.118-3.458v-6.682h2.184v12.896h-1.976l-.156-2.314c-.399.815-.997 1.456-1.794 1.924-.78.468-1.664.702-2.652.702zm10.173-.312v-18.72h2.184v18.72zm5.763 0v-18.72h2.184v18.72zm12.775 0v-18.2h2.184v8.034h9.438v-8.034h2.184v18.2h-2.184v-8.372h-9.438v8.372zm21.91 0v-16.406h-5.434v-1.794h13.052v1.794h-5.434v16.406zm10.285 0v-18.2h2.548l6.552 12.688 6.5-12.688h2.574v18.2h-2.184v-14.3l-6.084 11.7h-1.638l-6.084-11.674v14.274zm22.014 0v-18.2h2.184v16.458h8.476v1.742zm21.737-15.756c-.433 0-.797-.139-1.092-.416-.277-.295-.416-.659-.416-1.092 0-.416.139-.763.416-1.04.295-.277.659-.416 1.092-.416.416 0 .771.139 1.066.416s.442.624.442 1.04c0 .433-.147.797-.442 1.092-.295.277-.65.416-1.066.416zm-1.092 15.756v-12.896h2.184v12.896zm10.927.312c-1.543 0-2.826-.39-3.848-1.17-1.023-.78-1.621-1.837-1.794-3.172h2.236c.138.676.494 1.265 1.066 1.768.589.485 1.378.728 2.366.728.918 0 1.594-.191 2.028-.572.433-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.555-.26-1.344-.494-2.366-.702-.694-.139-1.387-.338-2.08-.598-.694-.26-1.274-.624-1.742-1.092-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.849-.728 1.993-1.092 3.432-1.092 1.369 0 2.487.347 3.354 1.04.884.676 1.395 1.647 1.534 2.912h-2.158c-.087-.659-.373-1.17-.858-1.534-.468-.381-1.101-.572-1.898-.572-.78 0-1.387.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.268.927.806 1.222.554.295 1.3.546 2.236.754.797.173 1.551.39 2.262.65.728.243 1.317.615 1.768 1.118.468.485.702 1.196.702 2.132.017 1.161-.425 2.123-1.326 2.886-.884.745-2.089 1.118-3.614 1.118zm19.881 0c-1.543 0-2.826-.39-3.848-1.17-1.023-.78-1.621-1.837-1.794-3.172h2.236c.138.676.494 1.265 1.066 1.768.589.485 1.378.728 2.366.728.918 0 1.594-.191 2.028-.572.433-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.555-.26-1.344-.494-2.366-.702-.694-.139-1.387-.338-2.08-.598-.694-.26-1.274-.624-1.742-1.092-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.849-.728 1.993-1.092 3.432-1.092 1.369 0 2.487.347 3.354 1.04.884.676 1.395 1.647 1.534 2.912h-2.158c-.087-.659-.373-1.17-.858-1.534-.468-.381-1.101-.572-1.898-.572-.78 0-1.387.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.268.927.806 1.222.554.295 1.3.546 2.236.754.797.173 1.551.39 2.262.65.728.243 1.317.615 1.768 1.118.468.485.702 1.196.702 2.132.017 1.161-.425 2.123-1.326 2.886-.884.745-2.089 1.118-3.614 1.118zm13.858 0c-1.231 0-2.323-.277-3.276-.832-.954-.572-1.708-1.361-2.262-2.366-.538-1.005-.806-2.193-.806-3.562 0-1.352.268-2.531.806-3.536.537-1.023 1.282-1.811 2.236-2.366.97-.572 2.088-.858 3.354-.858 1.248 0 2.322.286 3.224.858.918.555 1.62 1.291 2.106 2.21.485.919.728 1.907.728 2.964 0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.282.494 1.976.494.901 0 1.655-.208 2.262-.624.606-.416 1.048-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.968.321-2.782.962-.798.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73-.746-.659-1.664-.988-2.756-.988zm9.004 11.362v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.526 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.036.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm19.975 0c-1.178 0-2.106-.286-2.782-.858s-1.014-1.603-1.014-3.094v-7.098h-2.236v-1.846h2.236l.286-3.094h1.898v3.094h3.796v1.846h-3.796v7.098c0 .815.165 1.369.494 1.664.33.277.91.416 1.742.416h1.352v1.872zm16.936 0c-1.179 0-2.106-.286-2.782-.858s-1.014-1.603-1.014-3.094v-7.098h-2.236v-1.846h2.236l.286-3.094h1.898v3.094h3.796v1.846h-3.796v7.098c0 .815.164 1.369.494 1.664.329.277.91.416 1.742.416h1.352v1.872zm10.479.312c-1.213 0-2.305-.277-3.276-.832s-1.742-1.335-2.314-2.34c-.555-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.343-1.811 2.314-2.366.988-.555 2.089-.832 3.302-.832s2.305.277 3.276.832 1.733 1.343 2.288 2.366c.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.971.555-2.063.832-3.276.832zm0-1.872c.745 0 1.439-.182 2.08-.546s1.161-.91 1.56-1.638.598-1.629.598-2.704-.199-1.976-.598-2.704c-.381-.728-.893-1.274-1.534-1.638s-1.326-.546-2.054-.546c-.745 0-1.439.182-2.08.546s-1.161.91-1.56 1.638-.598 1.629-.598 2.704.199 1.976.598 2.704.91 1.274 1.534 1.638c.641.364 1.326.546 2.054.546zm-222.605 35.56c-1.179 0-2.106-.286-2.782-.858s-1.014-1.603-1.014-3.094v-7.098h-2.236v-1.846h2.236l.286-3.094h1.898v3.094h3.796v1.846h-3.796v7.098c0 .815.164 1.369.494 1.664.329.277.91.416 1.742.416h1.352v1.872zm4.958 0v-18.72h2.184v8.034c.434-.797 1.049-1.413 1.846-1.846.798-.451 1.664-.676 2.6-.676 1.491 0 2.687.468 3.588 1.404.902.919 1.352 2.34 1.352 4.264v7.54h-2.158v-7.306c0-2.687-1.083-4.03-3.25-4.03-1.126 0-2.071.407-2.834 1.222-.762.797-1.144 1.941-1.144 3.432v6.682zm20.677.312c-1.23 0-2.322-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.538-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21.486.919.728 1.907.728 2.964 0 .191-.008.381-.026.572v.65h-10.27c.052.988.278 1.811.676 2.47.416.641.928 1.127 1.534 1.456.624.329 1.283.494 1.976.494.902 0 1.656-.208 2.262-.624.607-.416 1.049-.979 1.326-1.69h2.158c-.346 1.196-1.014 2.193-2.002 2.99-.97.78-2.218 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.256 1.543-1.378 2.756h8.112c-.052-1.161-.45-2.071-1.196-2.73-.745-.659-1.664-.988-2.756-.988zm22.776 11.674c-1.057 0-2.002-.217-2.834-.65-.815-.433-1.439-1.04-1.872-1.82l-.208 2.158h-1.976v-18.72h2.184v7.956c.416-.624 1.005-1.187 1.768-1.69.78-.503 1.768-.754 2.964-.754 1.283 0 2.401.295 3.354.884s1.69 1.395 2.21 2.418c.537 1.023.806 2.184.806 3.484s-.269 2.461-.806 3.484c-.52 1.005-1.265 1.803-2.236 2.392-.953.572-2.071.858-3.354.858zm-.234-1.898c.867 0 1.629-.199 2.288-.598.659-.416 1.179-.988 1.56-1.716s.572-1.577.572-2.548-.191-1.82-.572-2.548-.901-1.291-1.56-1.69c-.659-.416-1.421-.624-2.288-.624s-1.629.208-2.288.624c-.659.399-1.179.962-1.56 1.69s-.572 1.577-.572 2.548.191 1.82.572 2.548.901 1.3 1.56 1.716c.659.399 1.421.598 2.288.598zm9.67 1.586v-12.896h1.976l.182 2.47c.399-.849 1.005-1.525 1.82-2.028s1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.641.26-1.153.711-1.534 1.352s-.572 1.525-.572 2.652v6.5zm14.839.312c-1.213 0-2.305-.277-3.276-.832s-1.742-1.335-2.314-2.34c-.555-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.343-1.811 2.314-2.366.988-.555 2.089-.832 3.302-.832s2.305.277 3.276.832 1.733 1.343 2.288 2.366c.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.971.555-2.063.832-3.276.832zm0-1.872c.745 0 1.439-.182 2.08-.546s1.161-.91 1.56-1.638.598-1.629.598-2.704-.199-1.976-.598-2.704c-.381-.728-.893-1.274-1.534-1.638s-1.326-.546-2.054-.546c-.745 0-1.439.182-2.08.546s-1.161.91-1.56 1.638-.598 1.629-.598 2.704.199 1.976.598 2.704.91 1.274 1.534 1.638c.641.364 1.326.546 2.054.546zm11.628 1.56-3.77-12.896h2.184l2.73 10.114 3.016-10.114h2.47l3.042 10.114 2.704-10.114h2.21l-3.77 12.896h-2.236l-3.172-10.634-3.172 10.634zm21.942.312c-1.543 0-2.825-.39-3.848-1.17s-1.621-1.837-1.794-3.172h2.236c.139.676.494 1.265 1.066 1.768.589.485 1.378.728 2.366.728.919 0 1.595-.191 2.028-.572.433-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.555-.26-1.343-.494-2.366-.702-.693-.139-1.387-.338-2.08-.598s-1.274-.624-1.742-1.092c-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.849-.728 1.993-1.092 3.432-1.092 1.369 0 2.487.347 3.354 1.04.884.676 1.395 1.647 1.534 2.912h-2.158c-.087-.659-.373-1.17-.858-1.534-.468-.381-1.101-.572-1.898-.572-.78 0-1.387.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.269.927.806 1.222.555.295 1.3.546 2.236.754.797.173 1.551.39 2.262.65.728.243 1.317.615 1.768 1.118.468.485.702 1.196.702 2.132.017 1.161-.425 2.123-1.326 2.886-.884.745-2.089 1.118-3.614 1.118zm13.858 0c-1.231 0-2.323-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.537-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21s.728 1.907.728 2.964c0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.283.494 1.976.494.901 0 1.655-.208 2.262-.624s1.049-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73s-1.664-.988-2.756-.988zm9.005 11.362v-12.896h1.976l.182 2.47c.398-.849 1.005-1.525 1.82-2.028.814-.503 1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.642.26-1.153.711-1.534 1.352-.382.641-.572 1.525-.572 2.652v6.5zm20.616.312c-1.075 0-1.968-.182-2.678-.546-.711-.364-1.24-.849-1.586-1.456-.347-.607-.52-1.265-.52-1.976 0-1.317.502-2.331 1.508-3.042 1.005-.711 2.374-1.066 4.108-1.066h3.484v-.156c0-1.127-.295-1.976-.884-2.548-.59-.589-1.378-.884-2.366-.884-.85 0-1.586.217-2.21.65-.607.416-.988 1.031-1.144 1.846h-2.236c.086-.936.398-1.725.936-2.366.554-.641 1.239-1.127 2.054-1.456.814-.347 1.681-.52 2.6-.52 1.802 0 3.154.485 4.056 1.456.918.953 1.378 2.227 1.378 3.822v7.93h-1.95l-.13-2.314c-.364.728-.902 1.352-1.612 1.872-.694.503-1.63.754-2.808.754zm.338-1.846c.832 0 1.542-.217 2.132-.65.606-.433 1.066-.997 1.378-1.69s.468-1.421.468-2.184v-.026h-3.302c-1.283 0-2.193.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.242 1.222.728 1.638.502.399 1.204.598 2.106.598zm9.438 1.534v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.526 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.036.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm20.729.312c-1.283 0-2.409-.295-3.38-.884-.953-.589-1.699-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.537-1.023 1.283-1.82 2.236-2.392.953-.589 2.08-.884 3.38-.884 1.057 0 1.993.217 2.808.65s1.447 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.629-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.381-.728.572-1.577.572-2.548s-.191-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.659-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.659.399-1.179.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.381.728.901 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm-145.136 35.586v-12.896h1.976l.182 2.47c.399-.849 1.006-1.525 1.82-2.028.815-.503 1.82-.754 3.016-.754v2.288h-.598c-.762 0-1.464.139-2.106.416-.641.26-1.152.711-1.534 1.352-.381.641-.572 1.525-.572 2.652v6.5zm14.761.312c-1.23 0-2.322-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.538-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21.486.919.728 1.907.728 2.964 0 .191-.008.381-.026.572v.65h-10.27c.052.988.278 1.811.676 2.47.416.641.928 1.127 1.534 1.456.624.329 1.283.494 1.976.494.902 0 1.656-.208 2.262-.624.607-.416 1.049-.979 1.326-1.69h2.158c-.346 1.196-1.014 2.193-2.002 2.99-.97.78-2.218 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.256 1.543-1.378 2.756h8.112c-.052-1.161-.45-2.071-1.196-2.73-.745-.659-1.664-.988-2.756-.988zm9.005 11.362v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.525 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.037.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm20.729.312c-1.283 0-2.409-.295-3.38-.884-.953-.589-1.699-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.537-1.023 1.283-1.82 2.236-2.392.953-.589 2.08-.884 3.38-.884 1.057 0 1.993.217 2.808.65s1.447 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.629-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.381-.728.572-1.577.572-2.548s-.191-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.659-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.659.399-1.179.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.381.728.901 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm16.04 1.898c-1.231 0-2.323-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.537-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21s.728 1.907.728 2.964c0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.283.494 1.976.494.901 0 1.655-.208 2.262-.624s1.049-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73s-1.664-.988-2.756-.988zm9.005 11.362v-12.896h1.976l.182 2.47c.398-.849 1.005-1.525 1.82-2.028.814-.503 1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.642.26-1.153.711-1.534 1.352-.382.641-.572 1.525-.572 2.652v6.5zm14.761.312c-1.231 0-2.323-.277-3.276-.832-.954-.572-1.708-1.361-2.262-2.366-.538-1.005-.806-2.193-.806-3.562 0-1.352.268-2.531.806-3.536.537-1.023 1.282-1.811 2.236-2.366.97-.572 2.088-.858 3.354-.858 1.248 0 2.322.286 3.224.858.918.555 1.62 1.291 2.106 2.21.485.919.728 1.907.728 2.964 0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.282.494 1.976.494.901 0 1.655-.208 2.262-.624.606-.416 1.048-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.968.321-2.782.962-.798.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73-.746-.659-1.664-.988-2.756-.988zm14.854 11.674c-1.282 0-2.409-.295-3.38-.884-.953-.589-1.698-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.538-1.023 1.283-1.82 2.236-2.392.954-.589 2.08-.884 3.38-.884 1.058 0 1.994.217 2.808.65.815.433 1.448 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.63-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.382-.728.572-1.577.572-2.548s-.19-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.658-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.658.399-1.178.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.382.728.902 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm10.997 1.716c-.434 0-.798-.139-1.092-.416-.278-.295-.416-.65-.416-1.066s.138-.763.416-1.04c.294-.295.658-.442 1.092-.442.416 0 .762.147 1.04.442.294.277.442.624.442 1.04s-.148.771-.442 1.066c-.278.277-.624.416-1.04.416z" fill="#0a0a0b"/><rect fill="#fcfcfd" height="213.045" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="534.857" y="77.5825"/><path d="m595.178 160v-18.2h6.396c1.283 0 2.34.208 3.172.624.849.399 1.482.953 1.898 1.664.416.693.624 1.473.624 2.34 0 1.179-.321 2.106-.962 2.782-.624.676-1.378 1.144-2.262 1.404.676.121 1.291.39 1.846.806s.988.936 1.3 1.56c.329.624.494 1.309.494 2.054 0 .919-.225 1.759-.676 2.522-.451.745-1.118 1.343-2.002 1.794-.884.433-1.959.65-3.224.65zm2.184-10.244h4.056c1.161 0 2.054-.269 2.678-.806.624-.555.936-1.317.936-2.288 0-.919-.312-1.655-.936-2.21-.607-.555-1.525-.832-2.756-.832h-3.978zm0 8.424h4.186c1.248 0 2.21-.286 2.886-.858.676-.589 1.014-1.404 1.014-2.444 0-1.023-.355-1.837-1.066-2.444-.711-.624-1.673-.936-2.886-.936h-4.134zm13.327 1.82v-12.896h1.976l.182 2.47c.398-.849 1.005-1.525 1.82-2.028.814-.503 1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.642.26-1.153.711-1.534 1.352-.382.641-.572 1.525-.572 2.652v6.5zm14.838.312c-1.213 0-2.305-.277-3.276-.832-.97-.555-1.742-1.335-2.314-2.34-.554-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.344-1.811 2.314-2.366.988-.555 2.089-.832 3.302-.832 1.214 0 2.306.277 3.276.832.971.555 1.734 1.343 2.288 2.366.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.97.555-2.062.832-3.276.832zm0-1.872c.746 0 1.439-.182 2.08-.546.642-.364 1.162-.91 1.56-1.638.399-.728.598-1.629.598-2.704s-.199-1.976-.598-2.704c-.381-.728-.892-1.274-1.534-1.638-.641-.364-1.326-.546-2.054-.546-.745 0-1.438.182-2.08.546-.641.364-1.161.91-1.56 1.638-.398.728-.598 1.629-.598 2.704s.2 1.976.598 2.704c.399.728.91 1.274 1.534 1.638.642.364 1.326.546 2.054.546zm11.629 1.56-3.77-12.896h2.184l2.73 10.114 3.016-10.114h2.47l3.042 10.114 2.704-10.114h2.21l-3.77 12.896h-2.236l-3.172-10.634-3.172 10.634zm21.941.312c-1.542 0-2.825-.39-3.848-1.17-1.022-.78-1.62-1.837-1.794-3.172h2.236c.139.676.494 1.265 1.066 1.768.59.485 1.378.728 2.366.728.919 0 1.595-.191 2.028-.572.434-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.554-.26-1.343-.494-2.366-.702-.693-.139-1.386-.338-2.08-.598-.693-.26-1.274-.624-1.742-1.092-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.85-.728 1.994-1.092 3.432-1.092 1.37 0 2.488.347 3.354 1.04.884.676 1.396 1.647 1.534 2.912h-2.158c-.086-.659-.372-1.17-.858-1.534-.468-.381-1.1-.572-1.898-.572-.78 0-1.386.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.269.927.806 1.222.555.295 1.3.546 2.236.754.798.173 1.552.39 2.262.65.728.243 1.318.615 1.768 1.118.468.485.702 1.196.702 2.132.018 1.161-.424 2.123-1.326 2.886-.884.745-2.088 1.118-3.614 1.118zm13.858 0c-1.23 0-2.322-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.538-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21.486.919.728 1.907.728 2.964 0 .191-.008.381-.026.572v.65h-10.27c.052.988.278 1.811.676 2.47.416.641.928 1.127 1.534 1.456.624.329 1.283.494 1.976.494.902 0 1.656-.208 2.262-.624.607-.416 1.049-.979 1.326-1.69h2.158c-.346 1.196-1.014 2.193-2.002 2.99-.97.78-2.218 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.256 1.543-1.378 2.756h8.112c-.052-1.161-.45-2.071-1.196-2.73-.745-.659-1.664-.988-2.756-.988zm9.005 11.362v-12.896h1.976l.182 2.47c.399-.849 1.005-1.525 1.82-2.028s1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.641.26-1.153.711-1.534 1.352s-.572 1.525-.572 2.652v6.5zm22.176.312c-1.282 0-2.409-.295-3.38-.884-.953-.589-1.698-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.538-1.023 1.283-1.82 2.236-2.392.954-.589 2.08-.884 3.38-.884 1.058 0 1.994.217 2.808.65.815.433 1.448 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.63-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.382-.728.572-1.577.572-2.548s-.19-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.658-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.658.399-1.178.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.382.728.902 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm16.118 1.898c-1.213 0-2.305-.277-3.276-.832-.97-.555-1.742-1.335-2.314-2.34-.554-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.344-1.811 2.314-2.366.988-.555 2.089-.832 3.302-.832 1.214 0 2.306.277 3.276.832.971.555 1.734 1.343 2.288 2.366.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.97.555-2.062.832-3.276.832zm0-1.872c.746 0 1.439-.182 2.08-.546.642-.364 1.162-.91 1.56-1.638.399-.728.598-1.629.598-2.704s-.199-1.976-.598-2.704c-.381-.728-.892-1.274-1.534-1.638-.641-.364-1.326-.546-2.054-.546-.745 0-1.438.182-2.08.546-.641.364-1.161.91-1.56 1.638-.398.728-.598 1.629-.598 2.704s.2 1.976.598 2.704c.399.728.91 1.274 1.534 1.638.642.364 1.326.546 2.054.546zm11.629 1.56-3.77-12.896h2.184l2.73 10.114 3.016-10.114h2.47l3.042 10.114 2.704-10.114h2.21l-3.77 12.896h-2.236l-3.172-10.634-3.172 10.634zm17.001 0v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.526 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.036.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm14.879 0v-18.72h2.184v18.72zm11.64.312c-1.214 0-2.306-.277-3.276-.832-.971-.555-1.742-1.335-2.314-2.34-.555-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.343-1.811 2.314-2.366.988-.555 2.088-.832 3.302-.832 1.213 0 2.305.277 3.276.832.97.555 1.733 1.343 2.288 2.366.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.971.555-2.063.832-3.276.832zm0-1.872c.745 0 1.438-.182 2.08-.546.641-.364 1.161-.91 1.56-1.638.398-.728.598-1.629.598-2.704s-.2-1.976-.598-2.704c-.382-.728-.893-1.274-1.534-1.638-.642-.364-1.326-.546-2.054-.546-.746 0-1.439.182-2.08.546-.642.364-1.162.91-1.56 1.638-.399.728-.598 1.629-.598 2.704s.199 1.976.598 2.704c.398.728.91 1.274 1.534 1.638.641.364 1.326.546 2.054.546zm13.801 1.872c-1.075 0-1.968-.182-2.678-.546-.711-.364-1.24-.849-1.586-1.456-.347-.607-.52-1.265-.52-1.976 0-1.317.502-2.331 1.508-3.042 1.005-.711 2.374-1.066 4.108-1.066h3.484v-.156c0-1.127-.295-1.976-.884-2.548-.59-.589-1.378-.884-2.366-.884-.85 0-1.586.217-2.21.65-.607.416-.988 1.031-1.144 1.846h-2.236c.086-.936.398-1.725.936-2.366.554-.641 1.239-1.127 2.054-1.456.814-.347 1.681-.52 2.6-.52 1.802 0 3.154.485 4.056 1.456.918.953 1.378 2.227 1.378 3.822v7.93h-1.95l-.13-2.314c-.364.728-.902 1.352-1.612 1.872-.694.503-1.63.754-2.808.754zm.338-1.846c.832 0 1.542-.217 2.132-.65.606-.433 1.066-.997 1.378-1.69s.468-1.421.468-2.184v-.026h-3.302c-1.283 0-2.193.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.242 1.222.728 1.638.502.399 1.204.598 2.106.598zm15.288 1.846c-1.283 0-2.409-.295-3.38-.884-.953-.589-1.699-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.537-1.023 1.283-1.82 2.236-2.392.953-.589 2.08-.884 3.38-.884 1.057 0 1.993.217 2.808.65s1.447 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.629-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.381-.728.572-1.577.572-2.548s-.191-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.659-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.659.399-1.179.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.381.728.901 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm15.182 1.898c-1.543 0-2.825-.39-3.848-1.17s-1.621-1.837-1.794-3.172h2.236c.139.676.494 1.265 1.066 1.768.589.485 1.378.728 2.366.728.919 0 1.595-.191 2.028-.572.433-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.555-.26-1.343-.494-2.366-.702-.693-.139-1.387-.338-2.08-.598s-1.274-.624-1.742-1.092c-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.849-.728 1.993-1.092 3.432-1.092 1.369 0 2.487.347 3.354 1.04.884.676 1.395 1.647 1.534 2.912h-2.158c-.087-.659-.373-1.17-.858-1.534-.468-.381-1.101-.572-1.898-.572-.78 0-1.387.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.269.927.806 1.222.555.295 1.3.546 2.236.754.797.173 1.551.39 2.262.65.728.243 1.317.615 1.768 1.118.468.485.702 1.196.702 2.132.017 1.161-.425 2.123-1.326 2.886-.884.745-2.089 1.118-3.614 1.118zm-211.316 34c-1.075 0-1.967-.182-2.678-.546s-1.239-.849-1.586-1.456-.52-1.265-.52-1.976c0-1.317.503-2.331 1.508-3.042s2.375-1.066 4.108-1.066h3.484v-.156c0-1.127-.295-1.976-.884-2.548-.589-.589-1.378-.884-2.366-.884-.849 0-1.586.217-2.21.65-.607.416-.988 1.031-1.144 1.846h-2.236c.087-.936.399-1.725.936-2.366.555-.641 1.239-1.127 2.054-1.456.815-.347 1.681-.52 2.6-.52 1.803 0 3.155.485 4.056 1.456.919.953 1.378 2.227 1.378 3.822v7.93h-1.95l-.13-2.314c-.364.728-.901 1.352-1.612 1.872-.693.503-1.629.754-2.808.754zm.338-1.846c.832 0 1.543-.217 2.132-.65.607-.433 1.066-.997 1.378-1.69s.468-1.421.468-2.184v-.026h-3.302c-1.283 0-2.193.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.243 1.222.728 1.638.503.399 1.205.598 2.106.598zm9.438 1.534v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.526 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.036.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm20.729.312c-1.282 0-2.409-.295-3.38-.884-.953-.589-1.698-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.269-2.453.806-3.458c.538-1.023 1.283-1.82 2.236-2.392.954-.589 2.08-.884 3.38-.884 1.058 0 1.994.217 2.808.65.815.433 1.448 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.759.754-2.938.754zm.234-1.898c.867 0 1.63-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.382-.728.572-1.577.572-2.548s-.19-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.658-.416-1.421-.624-2.288-.624-.849 0-1.612.208-2.288.624-.658.399-1.178.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.382.728.902 1.3 1.56 1.716.676.399 1.439.598 2.288.598zm17.123 1.586v-12.896h1.976l.182 2.47c.399-.849 1.006-1.525 1.82-2.028.815-.503 1.82-.754 3.016-.754v2.288h-.598c-.762 0-1.464.139-2.106.416-.641.26-1.152.711-1.534 1.352-.381.641-.572 1.525-.572 2.652v6.5zm14.152.312c-1.526 0-2.739-.459-3.64-1.378-.902-.936-1.352-2.366-1.352-4.29v-7.54h2.184v7.306c0 2.687 1.1 4.03 3.302 4.03 1.126 0 2.054-.399 2.782-1.196.745-.815 1.118-1.967 1.118-3.458v-6.682h2.184v12.896h-1.976l-.156-2.314c-.399.815-.997 1.456-1.794 1.924-.78.468-1.664.702-2.652.702zm10.173-.312v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.525 0 2.738.468 3.64 1.404.918.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.11-4.03-3.328-4.03-1.11 0-2.037.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm19.819.312c-1.543 0-2.826-.39-3.848-1.17-1.023-.78-1.621-1.837-1.794-3.172h2.236c.138.676.494 1.265 1.066 1.768.589.485 1.378.728 2.366.728.918 0 1.594-.191 2.028-.572.433-.399.65-.867.65-1.404 0-.78-.286-1.3-.858-1.56-.555-.26-1.344-.494-2.366-.702-.694-.139-1.387-.338-2.08-.598-.694-.26-1.274-.624-1.742-1.092-.468-.485-.702-1.118-.702-1.898 0-1.127.416-2.045 1.248-2.756.849-.728 1.993-1.092 3.432-1.092 1.369 0 2.487.347 3.354 1.04.884.676 1.395 1.647 1.534 2.912h-2.158c-.087-.659-.373-1.17-.858-1.534-.468-.381-1.101-.572-1.898-.572-.78 0-1.387.165-1.82.494-.416.329-.624.763-.624 1.3 0 .52.268.927.806 1.222.554.295 1.3.546 2.236.754.797.173 1.551.39 2.262.65.728.243 1.317.615 1.768 1.118.468.485.702 1.196.702 2.132.017 1.161-.425 2.123-1.326 2.886-.884.745-2.089 1.118-3.614 1.118zm20.036-.312c-1.178 0-2.106-.286-2.782-.858s-1.014-1.603-1.014-3.094v-7.098h-2.236v-1.846h2.236l.286-3.094h1.898v3.094h3.796v1.846h-3.796v7.098c0 .815.165 1.369.494 1.664.33.277.91.416 1.742.416h1.352v1.872zm4.959 0v-18.72h2.184v8.034c.433-.797 1.049-1.413 1.846-1.846.797-.451 1.664-.676 2.6-.676 1.491 0 2.687.468 3.588 1.404.901.919 1.352 2.34 1.352 4.264v7.54h-2.158v-7.306c0-2.687-1.083-4.03-3.25-4.03-1.127 0-2.071.407-2.834 1.222-.763.797-1.144 1.941-1.144 3.432v6.682zm20.677.312c-1.231 0-2.323-.277-3.276-.832-.953-.572-1.707-1.361-2.262-2.366-.537-1.005-.806-2.193-.806-3.562 0-1.352.269-2.531.806-3.536.537-1.023 1.283-1.811 2.236-2.366.971-.572 2.089-.858 3.354-.858 1.248 0 2.323.286 3.224.858.919.555 1.621 1.291 2.106 2.21s.728 1.907.728 2.964c0 .191-.009.381-.026.572v.65h-10.27c.052.988.277 1.811.676 2.47.416.641.927 1.127 1.534 1.456.624.329 1.283.494 1.976.494.901 0 1.655-.208 2.262-.624s1.049-.979 1.326-1.69h2.158c-.347 1.196-1.014 2.193-2.002 2.99-.971.78-2.219 1.17-3.744 1.17zm0-11.674c-1.04 0-1.967.321-2.782.962-.797.624-1.257 1.543-1.378 2.756h8.112c-.052-1.161-.451-2.071-1.196-2.73s-1.664-.988-2.756-.988zm20.072 11.674c-1.647 0-2.938-.459-3.874-1.378s-1.404-2.193-1.404-3.822h2.21c0 .919.225 1.69.676 2.314.45.624 1.239.936 2.366.936 1.092 0 1.846-.303 2.262-.91.433-.607.65-1.361.65-2.262v-13.39h2.184v13.39c0 1.612-.451 2.869-1.352 3.77-.884.901-2.124 1.352-3.718 1.352zm14.716 0c-1.334 0-2.496-.243-3.484-.728s-1.75-1.161-2.288-2.028c-.537-.867-.806-1.872-.806-3.016h2.288c0 .711.165 1.369.494 1.976.33.589.806 1.066 1.43 1.43.642.347 1.43.52 2.366.52 1.231 0 2.184-.295 2.86-.884s1.014-1.326 1.014-2.21c0-.728-.156-1.309-.468-1.742-.312-.451-.736-.815-1.274-1.092-.52-.277-1.126-.52-1.82-.728-.676-.208-1.386-.442-2.132-.702-1.404-.485-2.444-1.083-3.12-1.794-.676-.728-1.014-1.673-1.014-2.834-.017-.971.208-1.829.676-2.574.468-.763 1.127-1.352 1.976-1.768.867-.433 1.89-.65 3.068-.65 1.162 0 2.167.217 3.016.65.867.433 1.534 1.031 2.002 1.794.486.763.737 1.629.754 2.6h-2.288c0-.503-.13-.997-.39-1.482-.26-.503-.658-.91-1.196-1.222-.52-.312-1.178-.468-1.976-.468-.988-.017-1.802.234-2.444.754-.624.52-.936 1.239-.936 2.158 0 .78.217 1.378.65 1.794.451.416 1.075.763 1.872 1.04.798.26 1.716.563 2.756.91.867.312 1.647.676 2.34 1.092.694.416 1.231.953 1.612 1.612.399.659.598 1.499.598 2.522 0 .867-.225 1.69-.676 2.47-.45.763-1.135 1.387-2.054 1.872-.901.485-2.036.728-3.406.728zm17.31-16.068c-.433 0-.797-.139-1.092-.416-.277-.295-.416-.659-.416-1.092 0-.416.139-.763.416-1.04.295-.277.659-.416 1.092-.416.416 0 .772.139 1.066.416.295.277.442.624.442 1.04 0 .433-.147.797-.442 1.092-.294.277-.65.416-1.066.416zm-1.092 15.756v-12.896h2.184v12.896zm5.987 0v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.525 0 2.739.468 3.64 1.404.919.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.109-4.03-3.328-4.03-1.109 0-2.037.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm-159.241 34.312c-1.057 0-2.002-.217-2.834-.65-.815-.433-1.439-1.04-1.872-1.82l-.208 2.158h-1.976v-18.72h2.184v7.956c.416-.624 1.005-1.187 1.768-1.69.78-.503 1.768-.754 2.964-.754 1.283 0 2.401.295 3.354.884s1.69 1.395 2.21 2.418c.537 1.023.806 2.184.806 3.484s-.269 2.461-.806 3.484c-.52 1.005-1.265 1.803-2.236 2.392-.953.572-2.071.858-3.354.858zm-.234-1.898c.867 0 1.629-.199 2.288-.598.659-.416 1.179-.988 1.56-1.716s.572-1.577.572-2.548-.191-1.82-.572-2.548-.901-1.291-1.56-1.69c-.659-.416-1.421-.624-2.288-.624s-1.629.208-2.288.624c-.659.399-1.179.962-1.56 1.69s-.572 1.577-.572 2.548.191 1.82.572 2.548.901 1.3 1.56 1.716c.659.399 1.421.598 2.288.598zm13.96 1.898c-1.074 0-1.967-.182-2.678-.546-.71-.364-1.239-.849-1.586-1.456-.346-.607-.52-1.265-.52-1.976 0-1.317.503-2.331 1.508-3.042 1.006-.711 2.375-1.066 4.108-1.066h3.484v-.156c0-1.127-.294-1.976-.884-2.548-.589-.589-1.378-.884-2.366-.884-.849 0-1.586.217-2.21.65-.606.416-.988 1.031-1.144 1.846h-2.236c.087-.936.399-1.725.936-2.366.555-.641 1.24-1.127 2.054-1.456.815-.347 1.682-.52 2.6-.52 1.803 0 3.155.485 4.056 1.456.919.953 1.378 2.227 1.378 3.822v7.93h-1.95l-.13-2.314c-.364.728-.901 1.352-1.612 1.872-.693.503-1.629.754-2.808.754zm.338-1.846c.832 0 1.543-.217 2.132-.65.607-.433 1.066-.997 1.378-1.69s.468-1.421.468-2.184v-.026h-3.302c-1.282 0-2.192.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.243 1.222.728 1.638.503.399 1.205.598 2.106.598zm15.367 1.846c-1.231 0-2.34-.277-3.328-.832-.971-.572-1.742-1.361-2.314-2.366-.555-1.023-.832-2.21-.832-3.562s.277-2.531.832-3.536c.572-1.023 1.343-1.811 2.314-2.366.988-.572 2.097-.858 3.328-.858 1.525 0 2.808.399 3.848 1.196 1.057.797 1.724 1.863 2.002 3.198h-2.236c-.174-.797-.598-1.413-1.274-1.846-.676-.451-1.465-.676-2.366-.676-.728 0-1.413.182-2.054.546-.642.364-1.162.91-1.56 1.638-.399.728-.598 1.629-.598 2.704s.199 1.976.598 2.704c.398.728.918 1.283 1.56 1.664.641.364 1.326.546 2.054.546.901 0 1.69-.217 2.366-.65.676-.451 1.1-1.083 1.274-1.898h2.236c-.26 1.3-.919 2.357-1.976 3.172-1.058.815-2.349 1.222-3.874 1.222zm8.9-.312v-18.72h2.184v11.258l5.278-5.434h2.678l-5.72 5.824 6.448 7.072h-2.782l-5.902-6.682v6.682zm18.197-4.056c-.728 0-1.395-.095-2.002-.286l-1.3 1.222c.191.139.425.26.702.364.295.087.711.173 1.248.26.538.069 1.292.147 2.262.234 1.734.121 2.973.52 3.718 1.196.746.676 1.118 1.56 1.118 2.652 0 .745-.208 1.456-.624 2.132-.398.676-1.022 1.231-1.872 1.664-.832.433-1.906.65-3.224.65-1.161 0-2.192-.156-3.094-.468-.901-.295-1.603-.754-2.106-1.378-.502-.607-.754-1.378-.754-2.314 0-.485.13-1.014.39-1.586.26-.555.746-1.083 1.456-1.586-.381-.156-.71-.321-.988-.494-.26-.191-.502-.399-.728-.624v-.598l2.21-2.184c-1.022-.867-1.534-2.011-1.534-3.432 0-.849.2-1.621.598-2.314.399-.693.98-1.239 1.742-1.638.763-.416 1.69-.624 2.782-.624.746 0 1.422.104 2.028.312h4.758v1.638l-2.418.104c.503.728.754 1.569.754 2.522 0 .849-.208 1.621-.624 2.314-.398.693-.979 1.248-1.742 1.664-.745.399-1.664.598-2.756.598zm0-1.794c.919 0 1.647-.234 2.184-.702.555-.485.832-1.179.832-2.08 0-.884-.277-1.56-.832-2.028-.537-.485-1.265-.728-2.184-.728-.936 0-1.681.243-2.236.728-.537.468-.806 1.144-.806 2.028 0 .901.269 1.595.806 2.08.555.468 1.3.702 2.236.702zm-3.796 7.514c0 .867.364 1.508 1.092 1.924.728.433 1.638.65 2.73.65 1.075 0 1.933-.234 2.574-.702.659-.468.988-1.092.988-1.872 0-.555-.225-1.04-.676-1.456-.45-.399-1.282-.633-2.496-.702-.953-.069-1.776-.156-2.47-.26-.71.381-1.178.789-1.404 1.222-.225.451-.338.849-.338 1.196zm13.046-1.664v-12.896h1.976l.182 2.47c.399-.849 1.005-1.525 1.82-2.028s1.82-.754 3.016-.754v2.288h-.598c-.763 0-1.465.139-2.106.416-.641.26-1.153.711-1.534 1.352s-.572 1.525-.572 2.652v6.5zm14.839.312c-1.213 0-2.305-.277-3.276-.832s-1.742-1.335-2.314-2.34c-.555-1.023-.832-2.219-.832-3.588s.286-2.557.858-3.562c.572-1.023 1.343-1.811 2.314-2.366.988-.555 2.089-.832 3.302-.832s2.305.277 3.276.832 1.733 1.343 2.288 2.366c.572 1.005.858 2.193.858 3.562s-.286 2.565-.858 3.588c-.572 1.005-1.352 1.785-2.34 2.34-.971.555-2.063.832-3.276.832zm0-1.872c.745 0 1.439-.182 2.08-.546s1.161-.91 1.56-1.638.598-1.629.598-2.704-.199-1.976-.598-2.704c-.381-.728-.893-1.274-1.534-1.638s-1.326-.546-2.054-.546c-.745 0-1.439.182-2.08.546s-1.161.91-1.56 1.638-.598 1.629-.598 2.704.199 1.976.598 2.704.91 1.274 1.534 1.638c.641.364 1.326.546 2.054.546zm14.217 1.872c-1.526 0-2.739-.459-3.64-1.378-.902-.936-1.352-2.366-1.352-4.29v-7.54h2.184v7.306c0 2.687 1.1 4.03 3.302 4.03 1.126 0 2.054-.399 2.782-1.196.745-.815 1.118-1.967 1.118-3.458v-6.682h2.184v12.896h-1.976l-.156-2.314c-.399.815-.997 1.456-1.794 1.924-.78.468-1.664.702-2.652.702zm10.173-.312v-12.896h1.976l.13 2.314c.416-.815 1.014-1.456 1.794-1.924s1.664-.702 2.652-.702c1.525 0 2.738.468 3.64 1.404.918.919 1.378 2.34 1.378 4.264v7.54h-2.184v-7.306c0-2.687-1.11-4.03-3.328-4.03-1.11 0-2.037.407-2.782 1.222-.728.797-1.092 1.941-1.092 3.432v6.682zm20.729.312c-1.283 0-2.41-.295-3.38-.884-.954-.589-1.699-1.395-2.236-2.418-.52-1.023-.78-2.184-.78-3.484s.268-2.453.806-3.458c.537-1.023 1.282-1.82 2.236-2.392.953-.589 2.08-.884 3.38-.884 1.057 0 1.993.217 2.808.65.814.433 1.447 1.04 1.898 1.82v-7.982h2.184v18.72h-1.976l-.208-2.132c-.416.624-1.014 1.187-1.794 1.69s-1.76.754-2.938.754zm.234-1.898c.866 0 1.629-.199 2.288-.598.676-.416 1.196-.988 1.56-1.716.381-.728.572-1.577.572-2.548s-.191-1.82-.572-2.548c-.364-.728-.884-1.291-1.56-1.69-.659-.416-1.422-.624-2.288-.624-.85 0-1.612.208-2.288.624-.659.399-1.179.962-1.56 1.69-.364.728-.546 1.577-.546 2.548s.182 1.82.546 2.548c.381.728.901 1.3 1.56 1.716.676.399 1.438.598 2.288.598zm10.996 1.716c-.434 0-.798-.139-1.092-.416-.278-.295-.416-.65-.416-1.066s.138-.763.416-1.04c.294-.295.658-.442 1.092-.442.416 0 .762.147 1.04.442.294.277.442.624.442 1.04s-.148.771-.442 1.066c-.278.277-.624.416-1.04.416z" fill="#0a0a0b"/><rect fill="#fcfcfd" height="213.045" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="1004" y="78"/><path d="m1086.36 159v-18.2h2.19v8.034h9.43v-8.034h2.19v18.2h-2.19v-8.372h-9.43v8.372zm18.92 5.72 3.2-6.968h-.75l-5.13-11.648h2.37l4.26 10.036 4.53-10.036h2.26l-8.45 18.616zm17.68-5.408c-1.29 0-2.41-.295-3.38-.884-.96-.589-1.7-1.395-2.24-2.418-.52-1.023-.78-2.184-.78-3.484s.27-2.453.81-3.458c.53-1.023 1.28-1.82 2.23-2.392.96-.589 2.08-.884 3.38-.884 1.06 0 2 .217 2.81.65.82.433 1.45 1.04 1.9 1.82v-7.982h2.18v18.72h-1.97l-.21-2.132c-.42.624-1.02 1.187-1.8 1.69s-1.75.754-2.93.754zm.23-1.898c.87 0 1.63-.199 2.29-.598.67-.416 1.19-.988 1.56-1.716.38-.728.57-1.577.57-2.548s-.19-1.82-.57-2.548c-.37-.728-.89-1.291-1.56-1.69-.66-.416-1.42-.624-2.29-.624-.85 0-1.61.208-2.29.624-.66.399-1.18.962-1.56 1.69-.36.728-.54 1.577-.54 2.548s.18 1.82.54 2.548c.38.728.9 1.3 1.56 1.716.68.399 1.44.598 2.29.598zm10.24 1.586v-12.896h1.98l.18 2.47c.4-.849 1.01-1.525 1.82-2.028.82-.503 1.82-.754 3.02-.754v2.288h-.6c-.76 0-1.47.139-2.11.416-.64.26-1.15.711-1.53 1.352s-.57 1.525-.57 2.652v6.5zm13.74.312c-1.08 0-1.97-.182-2.68-.546s-1.24-.849-1.59-1.456c-.34-.607-.52-1.265-.52-1.976 0-1.317.51-2.331 1.51-3.042 1.01-.711 2.38-1.066 4.11-1.066h3.48v-.156c0-1.127-.29-1.976-.88-2.548-.59-.589-1.38-.884-2.37-.884-.85 0-1.58.217-2.21.65-.6.416-.98 1.031-1.14 1.846h-2.24c.09-.936.4-1.725.94-2.366.55-.641 1.24-1.127 2.05-1.456.82-.347 1.69-.52 2.6-.52 1.81 0 3.16.485 4.06 1.456.92.953 1.38 2.227 1.38 3.822v7.93h-1.95l-.13-2.314c-.37.728-.9 1.352-1.61 1.872-.7.503-1.63.754-2.81.754zm.34-1.846c.83 0 1.54-.217 2.13-.65.6-.433 1.06-.997 1.38-1.69.31-.693.46-1.421.46-2.184v-.026h-3.3c-1.28 0-2.19.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.24 1.222.73 1.638.5.399 1.2.598 2.11.598zm14.17 1.534c-1.17 0-2.1-.286-2.78-.858-.67-.572-1.01-1.603-1.01-3.094v-7.098h-2.24v-1.846h2.24l.28-3.094h1.9v3.094h3.8v1.846h-3.8v7.098c0 .815.17 1.369.5 1.664.33.277.91.416 1.74.416h1.35v1.872zm6.29-15.756c-.43 0-.8-.139-1.09-.416-.28-.295-.42-.659-.42-1.092 0-.416.14-.763.42-1.04.29-.277.66-.416 1.09-.416.42 0 .77.139 1.07.416.29.277.44.624.44 1.04 0 .433-.15.797-.44 1.092-.3.277-.65.416-1.07.416zm-1.09 15.756v-12.896h2.18v12.896zm11.86.312c-1.21 0-2.31-.277-3.28-.832s-1.74-1.335-2.31-2.34c-.55-1.023-.83-2.219-.83-3.588s.28-2.557.86-3.562c.57-1.023 1.34-1.811 2.31-2.366.99-.555 2.09-.832 3.3-.832 1.22 0 2.31.277 3.28.832s1.73 1.343 2.29 2.366c.57 1.005.85 2.193.85 3.562s-.28 2.565-.85 3.588c-.58 1.005-1.36 1.785-2.34 2.34-.97.555-2.07.832-3.28.832zm0-1.872c.75 0 1.44-.182 2.08-.546s1.16-.91 1.56-1.638.6-1.629.6-2.704-.2-1.976-.6-2.704c-.38-.728-.89-1.274-1.53-1.638-.65-.364-1.33-.546-2.06-.546-.74 0-1.44.182-2.08.546s-1.16.91-1.56 1.638-.6 1.629-.6 2.704.2 1.976.6 2.704.91 1.274 1.54 1.638c.64.364 1.32.546 2.05.546zm9.51 1.56v-12.896h1.98l.13 2.314c.41-.815 1.01-1.456 1.79-1.924s1.67-.702 2.65-.702c1.53 0 2.74.468 3.64 1.404.92.919 1.38 2.34 1.38 4.264v7.54h-2.18v-7.306c0-2.687-1.11-4.03-3.33-4.03-1.11 0-2.04.407-2.78 1.222-.73.797-1.09 1.941-1.09 3.432v6.682zm26.7.312c-1.54 0-2.82-.39-3.85-1.17-1.02-.78-1.62-1.837-1.79-3.172h2.23c.14.676.5 1.265 1.07 1.768.59.485 1.38.728 2.37.728.92 0 1.59-.191 2.02-.572.44-.399.65-.867.65-1.404 0-.78-.28-1.3-.85-1.56-.56-.26-1.35-.494-2.37-.702-.69-.139-1.39-.338-2.08-.598s-1.27-.624-1.74-1.092c-.47-.485-.7-1.118-.7-1.898 0-1.127.41-2.045 1.24-2.756.85-.728 2-1.092 3.44-1.092 1.37 0 2.48.347 3.35 1.04.88.676 1.4 1.647 1.53 2.912h-2.15c-.09-.659-.38-1.17-.86-1.534-.47-.381-1.1-.572-1.9-.572-.78 0-1.39.165-1.82.494-.42.329-.62.763-.62 1.3 0 .52.27.927.8 1.222.56.295 1.3.546 2.24.754.8.173 1.55.39 2.26.65.73.243 1.32.615 1.77 1.118.47.485.7 1.196.7 2.132.02 1.161-.42 2.123-1.33 2.886-.88.745-2.08 1.118-3.61 1.118zm12.57-.312c-1.18 0-2.1-.286-2.78-.858s-1.01-1.603-1.01-3.094v-7.098h-2.24v-1.846h2.24l.28-3.094h1.9v3.094h3.8v1.846h-3.8v7.098c0 .815.17 1.369.49 1.664.33.277.91.416 1.75.416h1.35v1.872zm10.4.312c-1.23 0-2.32-.277-3.27-.832-.96-.572-1.71-1.361-2.26-2.366-.54-1.005-.81-2.193-.81-3.562 0-1.352.27-2.531.81-3.536.53-1.023 1.28-1.811 2.23-2.366.97-.572 2.09-.858 3.36-.858 1.24 0 2.32.286 3.22.858.92.555 1.62 1.291 2.11 2.21.48.919.72 1.907.72 2.964 0 .191 0 .381-.02.572v.65h-10.27c.05.988.28 1.811.67 2.47.42.641.93 1.127 1.54 1.456.62.329 1.28.494 1.97.494.91 0 1.66-.208 2.27-.624.6-.416 1.04-.979 1.32-1.69h2.16c-.35 1.196-1.01 2.193-2 2.99-.97.78-2.22 1.17-3.75 1.17zm0-11.674c-1.04 0-1.96.321-2.78.962-.8.624-1.25 1.543-1.38 2.756h8.12c-.06-1.161-.45-2.071-1.2-2.73s-1.66-.988-2.76-.988zm9.01 17.082v-18.616h1.97l.21 2.132c.42-.624 1.01-1.187 1.77-1.69.78-.503 1.77-.754 2.96-.754 1.29 0 2.41.295 3.36.884s1.69 1.395 2.21 2.418c.54 1.023.8 2.184.8 3.484s-.26 2.461-.8 3.484c-.52 1.005-1.27 1.803-2.24 2.392-.95.572-2.07.858-3.35.858-1.06 0-2-.217-2.84-.65-.81-.433-1.43-1.04-1.87-1.82v7.878zm6.65-7.306c.87 0 1.63-.199 2.29-.598.66-.416 1.18-.988 1.56-1.716s.57-1.577.57-2.548-.19-1.82-.57-2.548-.9-1.291-1.56-1.69c-.66-.416-1.42-.624-2.29-.624-.86 0-1.62.208-2.28.624-.66.399-1.18.962-1.56 1.69s-.58 1.577-.58 2.548.2 1.82.58 2.548.9 1.3 1.56 1.716c.66.399 1.42.598 2.28.598zm17.88-14.17c-.43 0-.8-.139-1.09-.416-.28-.295-.42-.659-.42-1.092 0-.416.14-.763.42-1.04.29-.277.66-.416 1.09-.416.42 0 .77.139 1.07.416.29.277.44.624.44 1.04 0 .433-.15.797-.44 1.092-.3.277-.65.416-1.07.416zm-1.09 15.756v-12.896h2.18v12.896zm10.93.312c-1.55 0-2.83-.39-3.85-1.17s-1.62-1.837-1.8-3.172h2.24c.14.676.49 1.265 1.07 1.768.59.485 1.37.728 2.36.728.92 0 1.6-.191 2.03-.572.43-.399.65-.867.65-1.404 0-.78-.29-1.3-.86-1.56-.55-.26-1.34-.494-2.36-.702-.7-.139-1.39-.338-2.08-.598-.7-.26-1.28-.624-1.75-1.092-.46-.485-.7-1.118-.7-1.898 0-1.127.42-2.045 1.25-2.756.85-.728 1.99-1.092 3.43-1.092 1.37 0 2.49.347 3.36 1.04.88.676 1.39 1.647 1.53 2.912h-2.16c-.08-.659-.37-1.17-.86-1.534-.46-.381-1.1-.572-1.89-.572-.78 0-1.39.165-1.82.494-.42.329-.63.763-.63 1.3 0 .52.27.927.81 1.222.55.295 1.3.546 2.23.754.8.173 1.56.39 2.27.65.72.243 1.31.615 1.76 1.118.47.485.71 1.196.71 2.132.01 1.161-.43 2.123-1.33 2.886-.88.745-2.09 1.118-3.61 1.118zm-234.03 34c-1.23 0-2.34-.277-3.33-.832-.97-.572-1.74-1.361-2.31-2.366-.56-1.023-.84-2.21-.84-3.562s.28-2.531.84-3.536c.57-1.023 1.34-1.811 2.31-2.366.99-.572 2.1-.858 3.33-.858 1.52 0 2.81.399 3.85 1.196 1.05.797 1.72 1.863 2 3.198h-2.24c-.17-.797-.6-1.413-1.27-1.846-.68-.451-1.47-.676-2.37-.676-.73 0-1.41.182-2.05.546s-1.16.91-1.56 1.638-.6 1.629-.6 2.704.2 1.976.6 2.704.92 1.283 1.56 1.664c.64.364 1.32.546 2.05.546.9 0 1.69-.217 2.37-.65.67-.451 1.1-1.083 1.27-1.898h2.24c-.26 1.3-.92 2.357-1.98 3.172-1.05.815-2.35 1.222-3.87 1.222zm14.78 0c-1.22 0-2.31-.277-3.28-.832s-1.74-1.335-2.31-2.34c-.56-1.023-.84-2.219-.84-3.588s.29-2.557.86-3.562c.57-1.023 1.34-1.811 2.32-2.366s2.08-.832 3.3-.832c1.21 0 2.3.277 3.27.832s1.74 1.343 2.29 2.366c.57 1.005.86 2.193.86 3.562s-.29 2.565-.86 3.588c-.57 1.005-1.35 1.785-2.34 2.34-.97.555-2.06.832-3.27.832zm0-1.872c.74 0 1.43-.182 2.08-.546.64-.364 1.16-.91 1.56-1.638.39-.728.59-1.629.59-2.704s-.2-1.976-.59-2.704-.9-1.274-1.54-1.638-1.32-.546-2.05-.546c-.75 0-1.44.182-2.08.546s-1.16.91-1.56 1.638-.6 1.629-.6 2.704.2 1.976.6 2.704.91 1.274 1.53 1.638c.64.364 1.33.546 2.06.546zm9.51 1.56v-12.896h1.97l.16 1.872c.41-.693.97-1.231 1.66-1.612.7-.381 1.48-.572 2.34-.572 1.02 0 1.9.208 2.63.624.74.416 1.32 1.049 1.71 1.898.45-.78 1.07-1.395 1.85-1.846.8-.451 1.66-.676 2.57-.676 1.55 0 2.78.468 3.7 1.404.91.919 1.37 2.34 1.37 4.264v7.54h-2.15v-7.306c0-1.335-.27-2.34-.81-3.016s-1.31-1.014-2.31-1.014c-1.04 0-1.91.407-2.6 1.222-.68.797-1.02 1.941-1.02 3.432v6.682h-2.18v-7.306c0-1.335-.27-2.34-.81-3.016s-1.31-1.014-2.31-1.014c-1.02 0-1.88.407-2.58 1.222-.67.797-1.01 1.941-1.01 3.432v6.682zm23.25 5.72v-18.616h1.98l.21 2.132c.41-.624 1-1.187 1.77-1.69.78-.503 1.76-.754 2.96-.754 1.28 0 2.4.295 3.35.884.96.589 1.69 1.395 2.21 2.418.54 1.023.81 2.184.81 3.484s-.27 2.461-.81 3.484c-.52 1.005-1.26 1.803-2.23 2.392-.96.572-2.07.858-3.36.858-1.05 0-2-.217-2.83-.65-.82-.433-1.44-1.04-1.87-1.82v7.878zm6.66-7.306c.87 0 1.63-.199 2.29-.598.66-.416 1.18-.988 1.56-1.716s.57-1.577.57-2.548-.19-1.82-.57-2.548-.9-1.291-1.56-1.69c-.66-.416-1.42-.624-2.29-.624s-1.63.208-2.29.624c-.66.399-1.18.962-1.56 1.69s-.57 1.577-.57 2.548.19 1.82.57 2.548.9 1.3 1.56 1.716c.66.399 1.42.598 2.29.598zm9.67 1.586v-18.72h2.18v18.72zm11.56.312c-1.23 0-2.32-.277-3.27-.832-.96-.572-1.71-1.361-2.27-2.366-.53-1.005-.8-2.193-.8-3.562 0-1.352.27-2.531.8-3.536.54-1.023 1.29-1.811 2.24-2.366.97-.572 2.09-.858 3.35-.858 1.25 0 2.33.286 3.23.858.92.555 1.62 1.291 2.1 2.21.49.919.73 1.907.73 2.964 0 .191-.01.381-.02.572v.65h-10.27c.05.988.27 1.811.67 2.47.42.641.93 1.127 1.54 1.456.62.329 1.28.494 1.97.494.9 0 1.66-.208 2.26-.624.61-.416 1.05-.979 1.33-1.69h2.16c-.35 1.196-1.02 2.193-2 2.99-.98.78-2.22 1.17-3.75 1.17zm0-11.674c-1.04 0-1.97.321-2.78.962-.8.624-1.26 1.543-1.38 2.756h8.11c-.05-1.161-.45-2.071-1.19-2.73-.75-.659-1.67-.988-2.76-.988zm13.67 11.362c-1.18 0-2.11-.286-2.78-.858-.68-.572-1.02-1.603-1.02-3.094v-7.098h-2.23v-1.846h2.23l.29-3.094h1.9v3.094h3.79v1.846h-3.79v7.098c0 .815.16 1.369.49 1.664.33.277.91.416 1.74.416h1.36v1.872zm10.4.312c-1.23 0-2.32-.277-3.27-.832-.96-.572-1.71-1.361-2.27-2.366-.53-1.005-.8-2.193-.8-3.562 0-1.352.27-2.531.8-3.536.54-1.023 1.29-1.811 2.24-2.366.97-.572 2.09-.858 3.35-.858 1.25 0 2.33.286 3.23.858.92.555 1.62 1.291 2.1 2.21.49.919.73 1.907.73 2.964 0 .191-.01.381-.02.572v.65h-10.27c.05.988.27 1.811.67 2.47.42.641.93 1.127 1.54 1.456.62.329 1.28.494 1.97.494.9 0 1.66-.208 2.26-.624.61-.416 1.05-.979 1.33-1.69h2.16c-.35 1.196-1.02 2.193-2 2.99-.97.78-2.22 1.17-3.75 1.17zm0-11.674c-1.04 0-1.97.321-2.78.962-.8.624-1.26 1.543-1.38 2.756h8.11c-.05-1.161-.45-2.071-1.19-2.73-.75-.659-1.67-.988-2.76-.988zm20.18 11.674c-1.08 0-1.97-.182-2.68-.546s-1.24-.849-1.59-1.456c-.34-.607-.52-1.265-.52-1.976 0-1.317.51-2.331 1.51-3.042 1.01-.711 2.38-1.066 4.11-1.066h3.48v-.156c0-1.127-.29-1.976-.88-2.548-.59-.589-1.38-.884-2.37-.884-.85 0-1.58.217-2.21.65-.6.416-.98 1.031-1.14 1.846h-2.24c.09-.936.4-1.725.94-2.366.55-.641 1.24-1.127 2.05-1.456.82-.347 1.68-.52 2.6-.52 1.81 0 3.16.485 4.06 1.456.92.953 1.38 2.227 1.38 3.822v7.93h-1.95l-.13-2.314c-.37.728-.9 1.352-1.61 1.872-.7.503-1.63.754-2.81.754zm.34-1.846c.83 0 1.54-.217 2.13-.65.6-.433 1.06-.997 1.38-1.69.31-.693.46-1.421.46-2.184v-.026h-3.3c-1.28 0-2.19.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.24 1.222.73 1.638.5.399 1.2.598 2.11.598zm9.43 1.534v-12.896h1.98l.13 2.314c.42-.815 1.01-1.456 1.79-1.924s1.67-.702 2.66-.702c1.52 0 2.73.468 3.64 1.404.91.919 1.37 2.34 1.37 4.264v7.54h-2.18v-7.306c0-2.687-1.11-4.03-3.33-4.03-1.11 0-2.03.407-2.78 1.222-.73.797-1.09 1.941-1.09 3.432v6.682zm20.73.312c-1.28 0-2.41-.295-3.38-.884-.95-.589-1.7-1.395-2.23-2.418-.52-1.023-.78-2.184-.78-3.484s.27-2.453.8-3.458c.54-1.023 1.29-1.82 2.24-2.392.95-.589 2.08-.884 3.38-.884 1.06 0 1.99.217 2.81.65.81.433 1.44 1.04 1.89 1.82v-7.982h2.19v18.72h-1.98l-.21-2.132c-.41.624-1.01 1.187-1.79 1.69s-1.76.754-2.94.754zm.24-1.898c.86 0 1.63-.199 2.28-.598.68-.416 1.2-.988 1.56-1.716.39-.728.58-1.577.58-2.548s-.19-1.82-.58-2.548c-.36-.728-.88-1.291-1.56-1.69-.65-.416-1.42-.624-2.28-.624-.85 0-1.62.208-2.29.624-.66.399-1.18.962-1.56 1.69-.37.728-.55 1.577-.55 2.548s.18 1.82.55 2.548c.38.728.9 1.3 1.56 1.716.67.399 1.44.598 2.29.598zm22.22 1.586c-1.18 0-2.11-.286-2.79-.858-.67-.572-1.01-1.603-1.01-3.094v-7.098h-2.24v-1.846h2.24l.29-3.094h1.89v3.094h3.8v1.846h-3.8v7.098c0 .815.17 1.369.5 1.664.33.277.91.416 1.74.416h1.35v1.872zm4.95 0v-18.72h2.19v8.034c.43-.797 1.05-1.413 1.84-1.846.8-.451 1.67-.676 2.6-.676 1.49 0 2.69.468 3.59 1.404.9.919 1.35 2.34 1.35 4.264v7.54h-2.15v-7.306c0-2.687-1.09-4.03-3.25-4.03-1.13 0-2.08.407-2.84 1.222-.76.797-1.14 1.941-1.14 3.432v6.682zm20.68.312c-1.23 0-2.32-.277-3.27-.832-.96-.572-1.71-1.361-2.27-2.366-.53-1.005-.8-2.193-.8-3.562 0-1.352.27-2.531.8-3.536.54-1.023 1.29-1.811 2.24-2.366.97-.572 2.09-.858 3.35-.858 1.25 0 2.33.286 3.23.858.92.555 1.62 1.291 2.1 2.21.49.919.73 1.907.73 2.964 0 .191-.01.381-.02.572v.65h-10.27c.05.988.27 1.811.67 2.47.42.641.93 1.127 1.54 1.456.62.329 1.28.494 1.97.494.9 0 1.66-.208 2.26-.624.61-.416 1.05-.979 1.33-1.69h2.16c-.35 1.196-1.02 2.193-2 2.99-.98.78-2.22 1.17-3.75 1.17zm0-11.674c-1.04 0-1.97.321-2.78.962-.8.624-1.26 1.543-1.38 2.756h8.11c-.05-1.161-.45-2.071-1.19-2.73-.75-.659-1.67-.988-2.76-.988zm20.18 11.674c-1.08 0-1.97-.182-2.68-.546s-1.24-.849-1.59-1.456c-.34-.607-.52-1.265-.52-1.976 0-1.317.51-2.331 1.51-3.042 1.01-.711 2.38-1.066 4.11-1.066h3.48v-.156c0-1.127-.29-1.976-.88-2.548-.59-.589-1.38-.884-2.37-.884-.85 0-1.58.217-2.21.65-.6.416-.99 1.031-1.14 1.846h-2.24c.09-.936.4-1.725.94-2.366.55-.641 1.24-1.127 2.05-1.456.82-.347 1.68-.52 2.6-.52 1.81 0 3.16.485 4.06 1.456.92.953 1.38 2.227 1.38 3.822v7.93h-1.95l-.13-2.314c-.37.728-.9 1.352-1.62 1.872-.69.503-1.62.754-2.8.754zm.33-1.846c.84 0 1.55-.217 2.14-.65.6-.433 1.06-.997 1.37-1.69.32-.693.47-1.421.47-2.184v-.026h-3.3c-1.28 0-2.19.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.24 1.222.73 1.638.5.399 1.2.598 2.1.598zm9.44 7.254v-18.616h1.98l.21 2.132c.41-.624 1-1.187 1.77-1.69.78-.503 1.76-.754 2.96-.754 1.28 0 2.4.295 3.35.884.96.589 1.69 1.395 2.21 2.418.54 1.023.81 2.184.81 3.484s-.27 2.461-.81 3.484c-.52 1.005-1.26 1.803-2.23 2.392-.96.572-2.07.858-3.36.858-1.05 0-2-.217-2.83-.65-.82-.433-1.44-1.04-1.87-1.82v7.878zm6.66-7.306c.87 0 1.63-.199 2.29-.598.66-.416 1.18-.988 1.56-1.716s.57-1.577.57-2.548-.19-1.82-.57-2.548-.9-1.291-1.56-1.69c-.66-.416-1.42-.624-2.29-.624s-1.63.208-2.29.624c-.66.399-1.18.962-1.56 1.69s-.57 1.577-.57 2.548.19 1.82.57 2.548.9 1.3 1.56 1.716c.66.399 1.42.598 2.29.598zm9.67 7.306v-18.616h1.98l.2 2.132c.42-.624 1.01-1.187 1.77-1.69.78-.503 1.77-.754 2.97-.754 1.28 0 2.4.295 3.35.884s1.69 1.395 2.21 2.418c.54 1.023.81 2.184.81 3.484s-.27 2.461-.81 3.484c-.52 1.005-1.27 1.803-2.24 2.392-.95.572-2.07.858-3.35.858-1.06 0-2-.217-2.83-.65-.82-.433-1.44-1.04-1.88-1.82v7.878zm6.66-7.306c.86 0 1.62-.199 2.28-.598.66-.416 1.18-.988 1.56-1.716s.58-1.577.58-2.548-.2-1.82-.58-2.548-.9-1.291-1.56-1.69c-.66-.416-1.42-.624-2.28-.624-.87 0-1.63.208-2.29.624-.66.399-1.18.962-1.56 1.69s-.57 1.577-.57 2.548.19 1.82.57 2.548.9 1.3 1.56 1.716c.66.399 1.42.598 2.29.598zm17.87-14.17c-.43 0-.79-.139-1.09-.416-.28-.295-.42-.659-.42-1.092 0-.416.14-.763.42-1.04.3-.277.66-.416 1.09-.416.42 0 .77.139 1.07.416.29.277.44.624.44 1.04 0 .433-.15.797-.44 1.092-.3.277-.65.416-1.07.416zm-1.09 15.756v-12.896h2.18v12.896zm10.93.312c-1.55 0-2.83-.39-3.85-1.17s-1.62-1.837-1.79-3.172h2.23c.14.676.5 1.265 1.07 1.768.59.485 1.38.728 2.36.728.92 0 1.6-.191 2.03-.572.43-.399.65-.867.65-1.404 0-.78-.28-1.3-.86-1.56-.55-.26-1.34-.494-2.36-.702-.7-.139-1.39-.338-2.08-.598-.7-.26-1.28-.624-1.74-1.092-.47-.485-.71-1.118-.71-1.898 0-1.127.42-2.045 1.25-2.756.85-.728 1.99-1.092 3.43-1.092 1.37 0 2.49.347 3.36 1.04.88.676 1.39 1.647 1.53 2.912h-2.16c-.08-.659-.37-1.17-.85-1.534-.47-.381-1.11-.572-1.9-.572-.78 0-1.39.165-1.82.494-.42.329-.63.763-.63 1.3 0 .52.27.927.81 1.222.55.295 1.3.546 2.24.754.79.173 1.55.39 2.26.65.73.243 1.31.615 1.77 1.118.46.485.7 1.196.7 2.132.01 1.161-.43 2.123-1.33 2.886-.88.745-2.09 1.118-3.61 1.118zm-232.21 33.688v-11.05h-1.95v-1.846h1.95v-2.236c0-1.248.31-2.158.94-2.73.62-.572 1.53-.858 2.73-.858h1.3v1.872h-.97c-.66 0-1.12.139-1.4.416-.28.26-.42.711-.42 1.352v2.184h3.18v1.846h-3.18v11.05zm12.66.312c-1.52 0-2.74-.459-3.64-1.378-.9-.936-1.35-2.366-1.35-4.29v-7.54h2.18v7.306c0 2.687 1.1 4.03 3.31 4.03 1.12 0 2.05-.399 2.78-1.196.74-.815 1.12-1.967 1.12-3.458v-6.682h2.18v12.896h-1.98l-.15-2.314c-.4.815-1 1.456-1.8 1.924-.78.468-1.66.702-2.65.702zm10.17-.312v-18.72h2.19v18.72zm5.77 0v-18.72h2.18v18.72zm7.17 5.72 3.19-6.968h-.75l-5.12-11.648h2.36l4.27 10.036 4.52-10.036h2.26l-8.45 18.616zm21.25-21.476c-.44 0-.8-.139-1.1-.416-.27-.295-.41-.659-.41-1.092 0-.416.14-.763.41-1.04.3-.277.66-.416 1.1-.416.41 0 .77.139 1.06.416.3.277.44.624.44 1.04 0 .433-.14.797-.44 1.092-.29.277-.65.416-1.06.416zm-1.1 15.756v-12.896h2.19v12.896zm5.99 0v-12.896h1.98l.13 2.314c.41-.815 1.01-1.456 1.79-1.924s1.66-.702 2.65-.702c1.53 0 2.74.468 3.64 1.404.92.919 1.38 2.34 1.38 4.264v7.54h-2.18v-7.306c0-2.687-1.11-4.03-3.33-4.03-1.11 0-2.04.407-2.78 1.222-.73.797-1.1 1.941-1.1 3.432v6.682zm19.98 0c-1.18 0-2.11-.286-2.79-.858-.67-.572-1.01-1.603-1.01-3.094v-7.098h-2.24v-1.846h2.24l.29-3.094h1.89v3.094h3.8v1.846h-3.8v7.098c0 .815.17 1.369.5 1.664.33.277.91.416 1.74.416h1.35v1.872zm10.4.312c-1.23 0-2.33-.277-3.28-.832-.95-.572-1.71-1.361-2.26-2.366-.54-1.005-.81-2.193-.81-3.562 0-1.352.27-2.531.81-3.536.54-1.023 1.28-1.811 2.23-2.366.98-.572 2.09-.858 3.36-.858 1.25 0 2.32.286 3.22.858.92.555 1.62 1.291 2.11 2.21.48.919.73 1.907.73 2.964 0 .191-.01.381-.03.572v.65h-10.27c.05.988.28 1.811.68 2.47.41.641.92 1.127 1.53 1.456.62.329 1.28.494 1.98.494.9 0 1.65-.208 2.26-.624s1.05-.979 1.32-1.69h2.16c-.34 1.196-1.01 2.193-2 2.99-.97.78-2.22 1.17-3.74 1.17zm0-11.674c-1.04 0-1.97.321-2.79.962-.79.624-1.25 1.543-1.37 2.756h8.11c-.05-1.161-.45-2.071-1.2-2.73-.74-.659-1.66-.988-2.75-.988zm9 11.362v-12.896h1.98l.18 2.47c.4-.849 1-1.525 1.82-2.028.81-.503 1.82-.754 3.02-.754v2.288h-.6c-.77 0-1.47.139-2.11.416-.64.26-1.15.711-1.53 1.352s-.57 1.525-.57 2.652v6.5zm13.74.312c-1.08 0-1.97-.182-2.68-.546s-1.24-.849-1.59-1.456c-.34-.607-.52-1.265-.52-1.976 0-1.317.51-2.331 1.51-3.042 1.01-.711 2.38-1.066 4.11-1.066h3.48v-.156c0-1.127-.29-1.976-.88-2.548-.59-.589-1.38-.884-2.37-.884-.85 0-1.58.217-2.21.65-.6.416-.99 1.031-1.14 1.846h-2.24c.09-.936.4-1.725.94-2.366.55-.641 1.24-1.127 2.05-1.456.82-.347 1.68-.52 2.6-.52 1.81 0 3.16.485 4.06 1.456.92.953 1.38 2.227 1.38 3.822v7.93h-1.95l-.13-2.314c-.37.728-.9 1.352-1.62 1.872-.69.503-1.62.754-2.8.754zm.33-1.846c.84 0 1.55-.217 2.14-.65.6-.433 1.06-.997 1.37-1.69.32-.693.47-1.421.47-2.184v-.026h-3.3c-1.28 0-2.19.225-2.73.676-.52.433-.78.979-.78 1.638 0 .676.24 1.222.73 1.638.5.399 1.2.598 2.1.598zm15.37 1.846c-1.23 0-2.34-.277-3.33-.832-.97-.572-1.74-1.361-2.31-2.366-.56-1.023-.83-2.21-.83-3.562s.27-2.531.83-3.536c.57-1.023 1.34-1.811 2.31-2.366.99-.572 2.1-.858 3.33-.858 1.53 0 2.81.399 3.85 1.196 1.06.797 1.72 1.863 2 3.198h-2.23c-.18-.797-.6-1.413-1.28-1.846-.67-.451-1.46-.676-2.36-.676-.73 0-1.42.182-2.06.546s-1.16.91-1.56 1.638-.6 1.629-.6 2.704.2 1.976.6 2.704.92 1.283 1.56 1.664c.64.364 1.33.546 2.06.546.9 0 1.69-.217 2.36-.65.68-.451 1.1-1.083 1.28-1.898h2.23c-.26 1.3-.92 2.357-1.97 3.172-1.06.815-2.35 1.222-3.88 1.222zm13.64-.312c-1.18 0-2.1-.286-2.78-.858s-1.01-1.603-1.01-3.094v-7.098h-2.24v-1.846h2.24l.28-3.094h1.9v3.094h3.8v1.846h-3.8v7.098c0 .815.16 1.369.49 1.664.33.277.91.416 1.75.416h1.35v1.872zm6.29-15.756c-.44 0-.8-.139-1.1-.416-.27-.295-.41-.659-.41-1.092 0-.416.14-.763.41-1.04.3-.277.66-.416 1.1-.416.41 0 .77.139 1.06.416.3.277.44.624.44 1.04 0 .433-.14.797-.44 1.092-.29.277-.65.416-1.06.416zm-1.1 15.756v-12.896h2.19v12.896zm9.71 0-4.89-12.896h2.29l3.87 10.79 3.9-10.79h2.24l-4.89 12.896zm14.98.312c-1.23 0-2.32-.277-3.28-.832-.95-.572-1.71-1.361-2.26-2.366-.54-1.005-.81-2.193-.81-3.562 0-1.352.27-2.531.81-3.536.54-1.023 1.28-1.811 2.24-2.366.97-.572 2.08-.858 3.35-.858 1.25 0 2.32.286 3.22.858.92.555 1.62 1.291 2.11 2.21s.73 1.907.73 2.964c0 .191-.01.381-.03.572v.65h-10.27c.05.988.28 1.811.68 2.47.41.641.93 1.127 1.53 1.456.63.329 1.28.494 1.98.494.9 0 1.65-.208 2.26-.624s1.05-.979 1.33-1.69h2.15c-.34 1.196-1.01 2.193-2 2.99-.97.78-2.22 1.17-3.74 1.17zm0-11.674c-1.04 0-1.97.321-2.78.962-.8.624-1.26 1.543-1.38 2.756h8.11c-.05-1.161-.45-2.071-1.2-2.73-.74-.659-1.66-.988-2.75-.988zm9.76 11.492c-.44 0-.8-.139-1.1-.416-.27-.295-.41-.65-.41-1.066s.14-.763.41-1.04c.3-.295.66-.442 1.1-.442.41 0 .76.147 1.04.442.29.277.44.624.44 1.04s-.15.771-.44 1.066c-.28.277-.63.416-1.04.416z" fill="#0a0a0b"/><g clip-path="url(#a)"><rect fill="#fff" height="416.104" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="1004" y="336.143"/><g fill="#acffdd" stroke="#00dc82" stroke-width="3"><rect height="11.0029" rx="5.50143" width="61.7549" x="1020.25" y="493.146"/><rect height="11.0029" rx="5.50143" width="136.707" x="1020.25" y="515.995"/><rect height="95.1772" rx="4.5" width="319.944" x="1020.25" y="378.801"/><rect height="95.1772" rx="4.5" width="152.281" x="1020.25" y="548.175"/><rect height="95.1772" rx="4.5" width="152.281" x="1187.91" y="548.175"/><rect height="95.1772" rx="4.5" width="152.281" x="1020.25" y="662.52"/><rect height="95.1772" rx="4.5" width="152.281" x="1187.91" y="662.52"/></g><circle cx="1023.09" cy="354.78" fill="#7f7f8b" r="4.34369"/><circle cx="1038.73" cy="354.78" fill="#94949e" r="4.34369"/><circle cx="1054.37" cy="354.78" fill="#bfbfc5" r="4.34369"/></g><rect height="416" rx="6" stroke="#44444b" stroke-width="2" width="352" x="1004.43" y="336.417"/><g clip-path="url(#b)"><rect fill="#fff" height="416.104" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="62.5708" y="335.725"/><g fill="#ededee"><rect height="14.0029" rx="7.00143" width="64.7549" x="77.3193" y="491.229"/><rect height="14.0029" rx="7.00143" width="139.707" x="77.3193" y="514.078"/><rect height="98.1772" rx="6" width="322.944" x="77.3193" y="376.883"/><rect height="98.1772" rx="6" width="155.281" x="77.3193" y="546.257"/><rect height="98.1772" rx="6" width="155.281" x="244.982" y="546.257"/><rect height="98.1772" rx="6" width="155.281" x="77.3193" y="660.603"/><rect height="98.1772" rx="6" width="155.281" x="244.982" y="660.603"/></g><circle cx="81.663" cy="354.363" fill="#7f7f8b" r="4.34369"/><circle cx="97.2997" cy="354.363" fill="#94949e" r="4.34369"/><circle cx="112.936" cy="354.363" fill="#bfbfc5" r="4.34369"/></g><rect height="416" rx="6" stroke="#44444b" stroke-width="2" width="352" x="63" y="336"/><g clip-path="url(#c)"><rect fill="#fff" height="416.104" rx="8" stroke="#ededee" stroke-width="2" width="352.857" x="533.571" y="335.725"/><g fill="#ededee"><rect height="14.0029" rx="7.00143" width="64.7549" x="548.319" y="491.229"/><rect height="14.0029" rx="7.00143" width="139.707" x="548.319" y="514.078"/><rect height="98.1772" rx="6" width="322.944" x="548.319" y="376.883"/><rect height="98.1772" rx="6" width="155.281" x="548.319" y="546.257"/><rect height="98.1772" rx="6" width="155.281" x="715.982" y="546.257"/><rect height="98.1772" rx="6" width="155.281" x="548.319" y="660.603"/><rect height="98.1772" rx="6" width="155.281" x="715.982" y="660.603"/></g><circle cx="552.663" cy="354.363" fill="#7f7f8b" r="4.34369"/><circle cx="568.3" cy="354.363" fill="#94949e" r="4.34369"/><circle cx="583.936" cy="354.363" fill="#bfbfc5" r="4.34369"/></g><g stroke-width="2"><rect height="416" rx="6" stroke="#44444b" width="352" x="534" y="336"/><path d="m440.422 183.822h73.777" stroke="#bfbfc5"/><path d="m908.611 183.822h73.777" stroke="#bfbfc5"/><circle cx="414.857" cy="290.628" fill="#fff" r="20.9285" stroke="#ededee"/></g><path d="m414.699 297.628v-12.12l-2.26.5v-1.16l2.82-1.22h1.14v14z" fill="#0a0a0b"/><circle cx="887.714" cy="290.628" fill="#fff" r="20.9285" stroke="#ededee" stroke-width="2"/><path d="m882.751 297.628v-1.18c.947-.747 1.84-1.5 2.68-2.26.854-.773 1.607-1.533 2.26-2.28.667-.747 1.187-1.48 1.56-2.2.387-.72.58-1.413.58-2.08 0-.493-.086-.953-.26-1.38-.16-.427-.426-.767-.8-1.02-.373-.267-.88-.4-1.52-.4-.613 0-1.126.14-1.54.42-.413.267-.726.627-.94 1.08-.2.453-.3.94-.3 1.46h-1.62c0-.92.194-1.707.58-2.36.387-.667.914-1.173 1.58-1.52.667-.347 1.42-.52 2.26-.52 1.24 0 2.254.353 3.04 1.06.8.693 1.2 1.733 1.2 3.12 0 .827-.206 1.647-.62 2.46-.413.8-.94 1.58-1.58 2.34-.64.747-1.326 1.447-2.06 2.1-.72.653-1.393 1.24-2.02 1.76h6.76v1.4z" fill="#0a0a0b"/><circle cx="1356.93" cy="290.929" fill="#fff" r="20.9285" stroke="#ededee" stroke-width="2"/><path d="m1356.39 298.169c-.89 0-1.7-.16-2.42-.48-.72-.334-1.3-.827-1.74-1.48-.43-.654-.65-1.467-.68-2.44h1.7c.01.8.29 1.493.84 2.08.55.573 1.31.86 2.3.86s1.73-.274 2.22-.82c.51-.547.76-1.207.76-1.98 0-.654-.16-1.187-.48-1.6-.31-.414-.73-.72-1.26-.92-.52-.2-1.09-.3-1.72-.3h-1.04v-1.42h1.04c.91 0 1.61-.207 2.12-.62.52-.414.78-.994.78-1.74 0-.627-.21-1.14-.62-1.54-.4-.414-1-.62-1.8-.62-.77 0-1.39.233-1.86.7-.47.453-.73 1.026-.78 1.72h-1.7c.04-.76.24-1.434.6-2.02.37-.587.88-1.04 1.52-1.36.64-.334 1.38-.5 2.22-.5.91 0 1.66.16 2.26.48.61.32 1.07.746 1.38 1.28.32.533.48 1.12.48 1.76 0 .706-.19 1.353-.58 1.94-.39.573-.97.96-1.74 1.16.83.173 1.51.566 2.06 1.18.55.613.82 1.42.82 2.42 0 .773-.18 1.486-.54 2.14-.35.64-.87 1.153-1.56 1.54-.69.386-1.55.58-2.58.58z" fill="#0a0a0b"/><path d="m64 797 819.984-5.062" stroke="#888" stroke-width="3"/><path d="m255.113 831-6.312-16.8h2.184l5.304 14.664 5.352-14.664h2.136l-6.312 16.8zm12.072-14.544c-.4 0-.736-.128-1.008-.384-.256-.272-.384-.608-.384-1.008 0-.384.128-.704.384-.96.272-.256.608-.384 1.008-.384.384 0 .712.128.984.384s.408.576.408.96c0 .4-.136.736-.408 1.008-.272.256-.6.384-.984.384zm-1.008 14.544v-11.904h2.016v11.904zm10.086.288c-1.424 0-2.608-.36-3.552-1.08s-1.496-1.696-1.656-2.928h2.064c.128.624.456 1.168.984 1.632.544.448 1.272.672 2.184.672.848 0 1.472-.176 1.872-.528.4-.368.6-.8.6-1.296 0-.72-.264-1.2-.792-1.44-.512-.24-1.24-.456-2.184-.648-.64-.128-1.28-.312-1.92-.552s-1.176-.576-1.608-1.008c-.432-.448-.648-1.032-.648-1.752 0-1.04.384-1.888 1.152-2.544.784-.672 1.84-1.008 3.168-1.008 1.264 0 2.296.32 3.096.96.816.624 1.288 1.52 1.416 2.688h-1.992c-.08-.608-.344-1.08-.792-1.416-.432-.352-1.016-.528-1.752-.528-.72 0-1.28.152-1.68.456-.384.304-.576.704-.576 1.2 0 .48.248.856.744 1.128.512.272 1.2.504 2.064.696.736.16 1.432.36 2.088.6.672.224 1.216.568 1.632 1.032.432.448.648 1.104.648 1.968.016 1.072-.392 1.96-1.224 2.664-.816.688-1.928 1.032-3.336 1.032zm8.664-14.832c-.4 0-.736-.128-1.008-.384-.256-.272-.384-.608-.384-1.008 0-.384.128-.704.384-.96.272-.256.608-.384 1.008-.384.384 0 .712.128.984.384s.408.576.408.96c0 .4-.136.736-.408 1.008-.272.256-.6.384-.984.384zm-1.008 14.544v-11.904h2.016v11.904zm10.23 0c-1.088 0-1.944-.264-2.568-.792s-.936-1.48-.936-2.856v-6.552h-2.064v-1.704h2.064l.264-2.856h1.752v2.856h3.504v1.704h-3.504v6.552c0 .752.152 1.264.456 1.536.304.256.84.384 1.608.384h1.248v1.728zm9.673.288c-1.12 0-2.128-.256-3.024-.768s-1.608-1.232-2.136-2.16c-.512-.944-.768-2.048-.768-3.312s.264-2.36.792-3.288c.528-.944 1.24-1.672 2.136-2.184.912-.512 1.928-.768 3.048-.768s2.128.256 3.024.768 1.6 1.24 2.112 2.184c.528.928.792 2.024.792 3.288s-.264 2.368-.792 3.312c-.528.928-1.248 1.648-2.16 2.16-.896.512-1.904.768-3.024.768zm0-1.728c.688 0 1.328-.168 1.92-.504s1.072-.84 1.44-1.512.552-1.504.552-2.496-.184-1.824-.552-2.496c-.352-.672-.824-1.176-1.416-1.512s-1.224-.504-1.896-.504c-.688 0-1.328.168-1.92.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.84 1.176 1.416 1.512c.592.336 1.224.504 1.896.504zm8.779 1.44v-11.904h1.824l.168 2.28c.368-.784.928-1.408 1.68-1.872s1.68-.696 2.784-.696v2.112h-.552c-.704 0-1.352.128-1.944.384-.592.24-1.064.656-1.416 1.248s-.528 1.408-.528 2.448v6zm13.279.288c-1.424 0-2.608-.36-3.552-1.08s-1.496-1.696-1.656-2.928h2.064c.128.624.456 1.168.984 1.632.544.448 1.272.672 2.184.672.848 0 1.472-.176 1.872-.528.4-.368.6-.8.6-1.296 0-.72-.264-1.2-.792-1.44-.512-.24-1.24-.456-2.184-.648-.64-.128-1.28-.312-1.92-.552s-1.176-.576-1.608-1.008c-.432-.448-.648-1.032-.648-1.752 0-1.04.384-1.888 1.152-2.544.784-.672 1.84-1.008 3.168-1.008 1.264 0 2.296.32 3.096.96.816.624 1.288 1.52 1.416 2.688h-1.992c-.08-.608-.344-1.08-.792-1.416-.432-.352-1.016-.528-1.752-.528-.72 0-1.28.152-1.68.456-.384.304-.576.704-.576 1.2 0 .48.248.856.744 1.128.512.272 1.2.504 2.064.696.736.16 1.432.36 2.088.6.672.224 1.216.568 1.632 1.032.432.448.648 1.104.648 1.968.016 1.072-.392 1.96-1.224 2.664-.816.688-1.928 1.032-3.336 1.032zm19.264 0c-1.136 0-2.16-.256-3.072-.768-.896-.528-1.608-1.256-2.136-2.184-.512-.944-.768-2.04-.768-3.288s.256-2.336.768-3.264c.528-.944 1.24-1.672 2.136-2.184.912-.528 1.936-.792 3.072-.792 1.408 0 2.592.368 3.552 1.104.976.736 1.592 1.72 1.848 2.952h-2.064c-.16-.736-.552-1.304-1.176-1.704-.624-.416-1.352-.624-2.184-.624-.672 0-1.304.168-1.896.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.848 1.184 1.44 1.536c.592.336 1.224.504 1.896.504.832 0 1.56-.2 2.184-.6.624-.416 1.016-1 1.176-1.752h2.064c-.24 1.2-.848 2.176-1.824 2.928s-2.168 1.128-3.576 1.128zm12.175 0c-.992 0-1.816-.168-2.472-.504s-1.144-.784-1.464-1.344-.48-1.168-.48-1.824c0-1.216.464-2.152 1.392-2.808s2.192-.984 3.792-.984h3.216v-.144c0-1.04-.272-1.824-.816-2.352-.544-.544-1.272-.816-2.184-.816-.784 0-1.464.2-2.04.6-.56.384-.912.952-1.056 1.704h-2.064c.08-.864.368-1.592.864-2.184.512-.592 1.144-1.04 1.896-1.344.752-.32 1.552-.48 2.4-.48 1.664 0 2.912.448 3.744 1.344.848.88 1.272 2.056 1.272 3.528v7.32h-1.8l-.12-2.136c-.336.672-.832 1.248-1.488 1.728-.64.464-1.504.696-2.592.696zm.312-1.704c.768 0 1.424-.2 1.968-.6.56-.4.984-.92 1.272-1.56s.432-1.312.432-2.016v-.024h-3.048c-1.184 0-2.024.208-2.52.624-.48.4-.72.904-.72 1.512 0 .624.224 1.128.672 1.512.464.368 1.112.552 1.944.552zm8.713 1.416v-11.904h1.824l.12 2.136c.384-.752.936-1.344 1.656-1.776s1.536-.648 2.448-.648c1.408 0 2.528.432 3.36 1.296.848.848 1.271 2.16 1.271 3.936v6.96h-2.015v-6.744c0-2.48-1.024-3.72-3.072-3.72-1.024 0-1.88.376-2.568 1.128-.672.736-1.008 1.792-1.008 3.168v6.168zm20.085 0v-11.904h1.824l.168 2.28c.368-.784.928-1.408 1.68-1.872s1.68-.696 2.784-.696v2.112h-.552c-.704 0-1.352.128-1.944.384-.592.24-1.064.656-1.416 1.248s-.528 1.408-.528 2.448v6zm13.626.288c-1.136 0-2.144-.256-3.024-.768-.88-.528-1.576-1.256-2.088-2.184-.496-.928-.744-2.024-.744-3.288 0-1.248.248-2.336.744-3.264.496-.944 1.184-1.672 2.064-2.184.896-.528 1.928-.792 3.096-.792 1.152 0 2.144.264 2.976.792.848.512 1.496 1.192 1.944 2.04s.672 1.76.672 2.736c0 .176-.008.352-.024.528v.6h-9.48c.048.912.256 1.672.624 2.28.384.592.856 1.04 1.416 1.344.576.304 1.184.456 1.824.456.832 0 1.528-.192 2.088-.576s.968-.904 1.224-1.56h1.992c-.32 1.104-.936 2.024-1.848 2.76-.896.72-2.048 1.08-3.456 1.08zm0-10.776c-.96 0-1.816.296-2.568.888-.736.576-1.16 1.424-1.272 2.544h7.488c-.048-1.072-.416-1.912-1.104-2.52s-1.536-.912-2.544-.912zm12.272 10.776c-.992 0-1.816-.168-2.472-.504s-1.144-.784-1.464-1.344-.48-1.168-.48-1.824c0-1.216.464-2.152 1.392-2.808s2.192-.984 3.792-.984h3.216v-.144c0-1.04-.272-1.824-.816-2.352-.544-.544-1.272-.816-2.184-.816-.784 0-1.464.2-2.04.6-.56.384-.912.952-1.056 1.704h-2.064c.08-.864.368-1.592.864-2.184.512-.592 1.144-1.04 1.896-1.344.752-.32 1.552-.48 2.4-.48 1.664 0 2.912.448 3.744 1.344.848.88 1.272 2.056 1.272 3.528v7.32h-1.8l-.12-2.136c-.336.672-.832 1.248-1.488 1.728-.64.464-1.504.696-2.592.696zm.312-1.704c.768 0 1.424-.2 1.968-.6.56-.4.984-.92 1.272-1.56s.432-1.312.432-2.016v-.024h-3.048c-1.184 0-2.024.208-2.52.624-.48.4-.72.904-.72 1.512 0 .624.224 1.128.672 1.512.464.368 1.112.552 1.944.552zm14.112 1.704c-1.184 0-2.224-.272-3.12-.816-.88-.544-1.568-1.288-2.064-2.232-.48-.944-.72-2.016-.72-3.216s.248-2.264.744-3.192c.496-.944 1.184-1.68 2.064-2.208.88-.544 1.92-.816 3.12-.816.976 0 1.84.2 2.592.6s1.336.96 1.752 1.68v-7.368h2.016v17.28h-1.824l-.192-1.968c-.384.576-.936 1.096-1.656 1.56s-1.624.696-2.712.696zm.216-1.752c.8 0 1.504-.184 2.112-.552.624-.384 1.104-.912 1.44-1.584.352-.672.528-1.456.528-2.352s-.176-1.68-.528-2.352c-.336-.672-.816-1.192-1.44-1.56-.608-.384-1.312-.576-2.112-.576-.784 0-1.488.192-2.112.576-.608.368-1.088.888-1.44 1.56-.336.672-.504 1.456-.504 2.352s.168 1.68.504 2.352c.352.672.832 1.2 1.44 1.584.624.368 1.328.552 2.112.552zm7.847 4.32 1.392-5.304h2.088l-2.088 5.304zm16.785-2.568c-1.424 0-2.608-.36-3.552-1.08s-1.496-1.696-1.656-2.928h2.064c.128.624.456 1.168.984 1.632.544.448 1.272.672 2.184.672.848 0 1.472-.176 1.872-.528.4-.368.6-.8.6-1.296 0-.72-.264-1.2-.792-1.44-.512-.24-1.24-.456-2.184-.648-.64-.128-1.28-.312-1.92-.552s-1.176-.576-1.608-1.008c-.432-.448-.648-1.032-.648-1.752 0-1.04.384-1.888 1.152-2.544.784-.672 1.84-1.008 3.168-1.008 1.264 0 2.296.32 3.096.96.816.624 1.288 1.52 1.416 2.688h-1.992c-.08-.608-.344-1.08-.792-1.416-.432-.352-1.016-.528-1.752-.528-.72 0-1.28.152-1.68.456-.384.304-.576.704-.576 1.2 0 .48.248.856.744 1.128.512.272 1.2.504 2.064.696.736.16 1.432.36 2.088.6.672.224 1.216.568 1.632 1.032.432.448.648 1.104.648 1.968.016 1.072-.392 1.96-1.224 2.664-.816.688-1.928 1.032-3.336 1.032zm12.912 0c-1.136 0-2.16-.256-3.072-.768-.896-.528-1.608-1.256-2.136-2.184-.512-.944-.768-2.04-.768-3.288s.256-2.336.768-3.264c.528-.944 1.24-1.672 2.136-2.184.912-.528 1.936-.792 3.072-.792 1.408 0 2.592.368 3.552 1.104.976.736 1.592 1.72 1.848 2.952h-2.064c-.16-.736-.552-1.304-1.176-1.704-.624-.416-1.352-.624-2.184-.624-.672 0-1.304.168-1.896.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.848 1.184 1.44 1.536c.592.336 1.224.504 1.896.504.832 0 1.56-.2 2.184-.6.624-.416 1.016-1 1.176-1.752h2.064c-.24 1.2-.848 2.176-1.824 2.928s-2.168 1.128-3.576 1.128zm8.215-.288v-11.904h1.824l.168 2.28c.368-.784.928-1.408 1.68-1.872s1.68-.696 2.784-.696v2.112h-.552c-.704 0-1.352.128-1.944.384-.592.24-1.064.656-1.416 1.248s-.528 1.408-.528 2.448v6zm13.698.288c-1.12 0-2.128-.256-3.024-.768s-1.608-1.232-2.136-2.16c-.512-.944-.768-2.048-.768-3.312s.264-2.36.792-3.288c.528-.944 1.24-1.672 2.136-2.184.912-.512 1.928-.768 3.048-.768s2.128.256 3.024.768 1.6 1.24 2.112 2.184c.528.928.792 2.024.792 3.288s-.264 2.368-.792 3.312c-.528.928-1.248 1.648-2.16 2.16-.896.512-1.904.768-3.024.768zm0-1.728c.688 0 1.328-.168 1.92-.504s1.072-.84 1.44-1.512.552-1.504.552-2.496-.184-1.824-.552-2.496c-.352-.672-.824-1.176-1.416-1.512s-1.224-.504-1.896-.504c-.688 0-1.328.168-1.92.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.84 1.176 1.416 1.512c.592.336 1.224.504 1.896.504zm8.779 1.44v-17.28h2.016v17.28zm5.32 0v-17.28h2.016v17.28zm15.632.288c-.992 0-1.816-.168-2.472-.504s-1.144-.784-1.464-1.344-.48-1.168-.48-1.824c0-1.216.464-2.152 1.392-2.808s2.192-.984 3.792-.984h3.216v-.144c0-1.04-.272-1.824-.816-2.352-.544-.544-1.272-.816-2.184-.816-.784 0-1.464.2-2.04.6-.56.384-.912.952-1.056 1.704h-2.064c.08-.864.368-1.592.864-2.184.512-.592 1.144-1.04 1.896-1.344.752-.32 1.552-.48 2.4-.48 1.664 0 2.912.448 3.744 1.344.848.88 1.272 2.056 1.272 3.528v7.32h-1.8l-.12-2.136c-.336.672-.832 1.248-1.488 1.728-.64.464-1.504.696-2.592.696zm.312-1.704c.768 0 1.424-.2 1.968-.6.56-.4.984-.92 1.272-1.56s.432-1.312.432-2.016v-.024h-3.048c-1.184 0-2.024.208-2.52.624-.48.4-.72.904-.72 1.512 0 .624.224 1.128.672 1.512.464.368 1.112.552 1.944.552zm8.712 1.416v-11.904h1.824l.12 2.136c.384-.752.936-1.344 1.656-1.776s1.536-.648 2.448-.648c1.408 0 2.528.432 3.36 1.296.848.848 1.272 2.16 1.272 3.936v6.96h-2.016v-6.744c0-2.48-1.024-3.72-3.072-3.72-1.024 0-1.88.376-2.568 1.128-.672.736-1.008 1.792-1.008 3.168v6.168zm19.135.288c-1.184 0-2.224-.272-3.12-.816-.88-.544-1.568-1.288-2.064-2.232-.48-.944-.72-2.016-.72-3.216s.248-2.264.744-3.192c.496-.944 1.184-1.68 2.064-2.208.88-.544 1.92-.816 3.12-.816.976 0 1.84.2 2.592.6s1.336.96 1.752 1.68v-7.368h2.016v17.28h-1.824l-.192-1.968c-.384.576-.936 1.096-1.656 1.56s-1.624.696-2.712.696zm.216-1.752c.8 0 1.504-.184 2.112-.552.624-.384 1.104-.912 1.44-1.584.352-.672.528-1.456.528-2.352s-.176-1.68-.528-2.352c-.336-.672-.816-1.192-1.44-1.56-.608-.384-1.312-.576-2.112-.576-.784 0-1.488.192-2.112.576-.608.368-1.088.888-1.44 1.56-.336.672-.504 1.456-.504 2.352s.168 1.68.504 2.352c.352.672.832 1.2 1.44 1.584.624.368 1.328.552 2.112.552zm21.278 1.752c-1.136 0-2.16-.256-3.072-.768-.896-.528-1.608-1.256-2.136-2.184-.512-.944-.768-2.04-.768-3.288s.256-2.336.768-3.264c.528-.944 1.24-1.672 2.136-2.184.912-.528 1.936-.792 3.072-.792 1.408 0 2.592.368 3.552 1.104.976.736 1.592 1.72 1.848 2.952h-2.064c-.16-.736-.552-1.304-1.176-1.704-.624-.416-1.352-.624-2.184-.624-.672 0-1.304.168-1.896.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.848 1.184 1.44 1.536c.592.336 1.224.504 1.896.504.832 0 1.56-.2 2.184-.6.624-.416 1.016-1 1.176-1.752h2.064c-.24 1.2-.848 2.176-1.824 2.928s-2.168 1.128-3.576 1.128zm8.215-.288v-17.28h2.016v17.28zm6.545-14.544c-.4 0-.736-.128-1.008-.384-.256-.272-.384-.608-.384-1.008 0-.384.128-.704.384-.96.272-.256.608-.384 1.008-.384.384 0 .712.128.984.384s.408.576.408.96c0 .4-.136.736-.408 1.008-.272.256-.6.384-.984.384zm-1.008 14.544v-11.904h2.016v11.904zm10.998.288c-1.136 0-2.16-.256-3.072-.768-.896-.528-1.608-1.256-2.136-2.184-.512-.944-.768-2.04-.768-3.288s.256-2.336.768-3.264c.528-.944 1.24-1.672 2.136-2.184.912-.528 1.936-.792 3.072-.792 1.408 0 2.592.368 3.552 1.104.976.736 1.592 1.72 1.848 2.952h-2.064c-.16-.736-.552-1.304-1.176-1.704-.624-.416-1.352-.624-2.184-.624-.672 0-1.304.168-1.896.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.848 1.184 1.44 1.536c.592.336 1.224.504 1.896.504.832 0 1.56-.2 2.184-.6.624-.416 1.016-1 1.176-1.752h2.064c-.24 1.2-.848 2.176-1.824 2.928s-2.168 1.128-3.576 1.128zm8.215-.288v-17.28h2.016v10.392l4.872-5.016h2.472l-5.28 5.376 5.952 6.528h-2.568l-5.448-6.168v6.168zm23.87.288c-1.12 0-2.128-.256-3.024-.768s-1.608-1.232-2.136-2.16c-.512-.944-.768-2.048-.768-3.312s.264-2.36.792-3.288c.528-.944 1.24-1.672 2.136-2.184.912-.512 1.928-.768 3.048-.768s2.128.256 3.024.768 1.6 1.24 2.112 2.184c.528.928.792 2.024.792 3.288s-.264 2.368-.792 3.312c-.528.928-1.248 1.648-2.16 2.16-.896.512-1.904.768-3.024.768zm0-1.728c.688 0 1.328-.168 1.92-.504s1.072-.84 1.44-1.512.552-1.504.552-2.496-.184-1.824-.552-2.496c-.352-.672-.824-1.176-1.416-1.512s-1.224-.504-1.896-.504c-.688 0-1.328.168-1.92.504s-1.072.84-1.44 1.512-.552 1.504-.552 2.496.184 1.824.552 2.496.84 1.176 1.416 1.512c.592.336 1.224.504 1.896.504zm8.779 1.44v-11.904h1.824l.12 2.136c.384-.752.936-1.344 1.656-1.776s1.536-.648 2.448-.648c1.408 0 2.528.432 3.36 1.296.848.848 1.272 2.16 1.272 3.936v6.96h-2.016v-6.744c0-2.48-1.024-3.72-3.072-3.72-1.024 0-1.88.376-2.568 1.128-.672.736-1.008 1.792-1.008 3.168v6.168zm20.086 0v-17.28h2.016v17.28zm6.544-14.544c-.4 0-.736-.128-1.008-.384-.256-.272-.384-.608-.384-1.008 0-.384.128-.704.384-.96.272-.256.608-.384 1.008-.384.384 0 .712.128.984.384s.408.576.408.96c0 .4-.136.736-.408 1.008-.272.256-.6.384-.984.384zm-1.008 14.544v-11.904h2.016v11.904zm5.526 0v-11.904h1.824l.12 2.136c.384-.752.936-1.344 1.656-1.776s1.536-.648 2.448-.648c1.408 0 2.528.432 3.36 1.296.848.848 1.272 2.16 1.272 3.936v6.96h-2.016v-6.744c0-2.48-1.024-3.72-3.072-3.72-1.024 0-1.88.376-2.568 1.128-.672.736-1.008 1.792-1.008 3.168v6.168zm13.734 0v-17.28h2.016v10.392l4.872-5.016h2.472l-5.28 5.376 5.952 6.528h-2.568l-5.448-6.168v6.168zm15.951.288c-1.424 0-2.608-.36-3.552-1.08s-1.496-1.696-1.656-2.928h2.064c.128.624.456 1.168.984 1.632.544.448 1.272.672 2.184.672.848 0 1.472-.176 1.872-.528.4-.368.6-.8.6-1.296 0-.72-.264-1.2-.792-1.44-.512-.24-1.24-.456-2.184-.648-.64-.128-1.28-.312-1.92-.552s-1.176-.576-1.608-1.008c-.432-.448-.648-1.032-.648-1.752 0-1.04.384-1.888 1.152-2.544.784-.672 1.84-1.008 3.168-1.008 1.264 0 2.296.32 3.096.96.816.624 1.288 1.52 1.416 2.688h-1.992c-.08-.608-.344-1.08-.792-1.416-.432-.352-1.016-.528-1.752-.528-.72 0-1.28.152-1.68.456-.384.304-.576.704-.576 1.2 0 .48.248.856.744 1.128.512.272 1.2.504 2.064.696.736.16 1.432.36 2.088.6.672.224 1.216.568 1.632 1.032.432.448.648 1.104.648 1.968.016 1.072-.392 1.96-1.224 2.664-.816.688-1.928 1.032-3.336 1.032zm8.136-.168c-.4 0-.736-.128-1.008-.384-.256-.272-.384-.6-.384-.984s.128-.704.384-.96c.272-.272.608-.408 1.008-.408.384 0 .704.136.96.408.272.256.408.576.408.96s-.136.712-.408.984c-.256.256-.576.384-.96.384z" fill="#444"/><path d="m63 782h2v30h-2z" fill="#888"/><path d="m884 779h3v30h-3z" fill="#888"/></svg> | docs/public/assets/docs/concepts/rendering/light/ssr.svg | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.0004730685905087739,
0.0004730685905087739,
0.0004730685905087739,
0.0004730685905087739,
0
]
|
{
"id": 2,
"code_window": [
"import { defineComponent, h } from 'vue'\n",
"import type { Component } from 'vue'\n",
"\n",
"const Fragment = defineComponent({\n",
" setup (_props, { slots }) {\n",
" return () => slots.default?.()\n",
" }\n",
"})\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'FragmentWrapper',\n"
],
"file_path": "packages/nuxt/src/app/components/utils.ts",
"type": "add",
"edit_start_line_idx": 4
} | import type { Ref, VNode } from 'vue'
import { computed, defineComponent, h, inject, nextTick, onMounted, Transition, unref } from 'vue'
import type { RouteLocationNormalizedLoaded } from 'vue-router'
import { _wrapIf } from './utils'
import { useRoute } from '#app'
// @ts-ignore
import { useRoute as useVueRouterRoute } from '#build/pages'
// @ts-ignore
import layouts from '#build/layouts'
// @ts-ignore
import { appLayoutTransition as defaultLayoutTransition } from '#build/nuxt.config.mjs'
// TODO: revert back to defineAsyncComponent when https://github.com/vuejs/core/issues/6638 is resolved
const LayoutLoader = defineComponent({
inheritAttrs: false,
props: {
name: String,
...process.dev ? { hasTransition: Boolean } : {}
},
async setup (props, context) {
let vnode: VNode
if (process.dev && process.client) {
onMounted(() => {
nextTick(() => {
if (props.name && ['#comment', '#text'].includes(vnode?.el?.nodeName)) {
console.warn(`[nuxt] \`${props.name}\` layout does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
const LayoutComponent = await layouts[props.name]().then((r: any) => r.default || r)
return () => {
if (process.dev && process.client && props.hasTransition) {
vnode = h(LayoutComponent, context.attrs, context.slots)
return vnode
}
return h(LayoutComponent, context.attrs, context.slots)
}
}
})
export default defineComponent({
inheritAttrs: false,
props: {
name: {
type: [String, Boolean, Object] as unknown as () => string | false | Ref<string | false>,
default: null
}
},
setup (props, context) {
// Need to ensure (if we are not a child of `<NuxtPage>`) that we use synchronous route (not deferred)
const injectedRoute = inject('_route') as RouteLocationNormalizedLoaded
const route = injectedRoute === useRoute() ? useVueRouterRoute() : injectedRoute
const layout = computed(() => unref(props.name) ?? route.meta.layout as string ?? 'default')
let vnode: VNode
let _layout: string | false
if (process.dev && process.client) {
onMounted(() => {
nextTick(() => {
if (_layout && _layout in layouts && ['#comment', '#text'].includes(vnode?.el?.nodeName)) {
console.warn(`[nuxt] \`${_layout}\` layout does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
return () => {
const hasLayout = layout.value && layout.value in layouts
if (process.dev && layout.value && !hasLayout && layout.value !== 'default') {
console.warn(`Invalid layout \`${layout.value}\` selected.`)
}
const transitionProps = route.meta.layoutTransition ?? defaultLayoutTransition
// We avoid rendering layout transition if there is no layout to render
return _wrapIf(Transition, hasLayout && transitionProps, {
default: () => _wrapIf(LayoutLoader, hasLayout && {
key: layout.value,
name: layout.value,
...(process.dev ? { hasTransition: !!transitionProps } : {}),
...context.attrs
}, context.slots).default()
}).default()
}
}
})
| packages/nuxt/src/app/components/layout.ts | 1 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.0060382625088095665,
0.00164426164701581,
0.00017146245227195323,
0.0005060142721049488,
0.0019329970236867666
]
|
{
"id": 2,
"code_window": [
"import { defineComponent, h } from 'vue'\n",
"import type { Component } from 'vue'\n",
"\n",
"const Fragment = defineComponent({\n",
" setup (_props, { slots }) {\n",
" return () => slots.default?.()\n",
" }\n",
"})\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'FragmentWrapper',\n"
],
"file_path": "packages/nuxt/src/app/components/utils.ts",
"type": "add",
"edit_start_line_idx": 4
} | <template>
<div>
<div>nested/[foo]/index.vue</div>
<div>foo: {{ $route.params.foo }}</div>
</div>
</template>
| test/fixtures/basic/pages/nested/[foo]/index.vue | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.000165220073540695,
0.000165220073540695,
0.000165220073540695,
0.000165220073540695,
0
]
|
{
"id": 2,
"code_window": [
"import { defineComponent, h } from 'vue'\n",
"import type { Component } from 'vue'\n",
"\n",
"const Fragment = defineComponent({\n",
" setup (_props, { slots }) {\n",
" return () => slots.default?.()\n",
" }\n",
"})\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'FragmentWrapper',\n"
],
"file_path": "packages/nuxt/src/app/components/utils.ts",
"type": "add",
"edit_start_line_idx": 4
} | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="147" height="40">
<radialGradient id="a" cy="0%" r="100.11%" gradientTransform="matrix(0 .9989 -1.152 0 .5 -.5)">
<stop offset="0" stop-color="#20c6b7"/>
<stop offset="1" stop-color="#4d9abf"/>
</radialGradient>
<g fill="none" fill-rule="evenodd">
<path fill="#0e1e25" d="m53.37 12.978.123 2.198c1.403-1.7 3.245-2.55 5.525-2.55 3.951 0 5.962 2.268 6.032 6.804v12.568h-4.26v-12.322c0-1.207-.26-2.1-.78-2.681-.52-.58-1.371-.87-2.552-.87-1.719 0-3 .78-3.84 2.338v13.535h-4.262v-19.02h4.016zm24.378 19.372c-2.7 0-4.89-.852-6.567-2.557-1.678-1.705-2.517-3.976-2.517-6.812v-.527c0-1.898.365-3.595 1.096-5.089.73-1.494 1.757-2.657 3.078-3.49 1.321-.831 2.794-1.247 4.42-1.247 2.583 0 4.58.826 5.988 2.478 1.41 1.653 2.114 3.99 2.114 7.014v1.723h-12.4c.13 1.57.652 2.812 1.57 3.726s2.073 1.371 3.464 1.371c1.952 0 3.542-.79 4.77-2.373l2.297 2.198c-.76 1.136-1.774 2.018-3.042 2.645-1.269.627-2.692.94-4.27.94zm-.508-16.294c-1.17 0-2.113.41-2.832 1.23-.72.82-1.178 1.963-1.377 3.428h8.12v-.317c-.094-1.43-.474-2.51-1.14-3.243-.667-.732-1.59-1.098-2.771-1.098zm16.765-7.7v4.623h3.35v3.164h-3.35v10.617c0 .726.144 1.25.43 1.573.286.322.798.483 1.535.483a6.55 6.55 0 0 0 1.49-.176v3.305c-.97.27-1.905.404-2.806.404-3.273 0-4.91-1.81-4.91-5.431v-10.776h-3.124v-3.164h3.122v-4.623h4.261zm11.137 23.643h-4.262v-27h4.262zm9.172 0h-4.262v-19.02h4.262zm-4.525-23.96c0-.655.207-1.2.622-1.634.416-.433 1.009-.65 1.78-.65.772 0 1.368.217 1.79.65.42.434.63.979.63 1.635 0 .644-.21 1.18-.63 1.608-.422.428-1.018.642-1.79.642-.771 0-1.364-.214-1.78-.642-.415-.427-.622-.964-.622-1.608zm10.663 23.96v-15.857h-2.894v-3.164h2.894v-1.74c0-2.11.584-3.738 1.753-4.887 1.17-1.148 2.806-1.722 4.91-1.722.749 0 1.544.105 2.386.316l-.105 3.34a8.375 8.375 0 0 0 -1.631-.14c-2.035 0-3.052 1.048-3.052 3.146v1.687h3.858v3.164h-3.858v15.856h-4.261zm17.87-6.117 3.858-12.903h4.542l-7.54 21.903c-1.158 3.199-3.122 4.799-5.893 4.799-.62 0-1.304-.106-2.052-.317v-3.305l.807.053c1.075 0 1.885-.196 2.429-.589.543-.392.973-1.051 1.289-1.977l.613-1.635-6.664-18.932h4.595z"/>
<path fill="url(#a)" fill-rule="nonzero" d="m28.589 14.135-.014-.006c-.008-.003-.016-.006-.023-.013a.11.11 0 0 1 -.028-.093l.773-4.726 3.625 3.626-3.77 1.604a.083.083 0 0 1 -.033.006h-.015c-.005-.003-.01-.007-.02-.017a1.716 1.716 0 0 0 -.495-.381zm5.258-.288 3.876 3.876c.805.806 1.208 1.208 1.355 1.674.022.069.04.138.054.209l-9.263-3.923a.728.728 0 0 0 -.015-.006c-.037-.015-.08-.032-.08-.07s.044-.056.081-.071l.012-.005zm5.127 7.003c-.2.376-.59.766-1.25 1.427l-4.37 4.369-5.652-1.177-.03-.006c-.05-.008-.103-.017-.103-.062a1.706 1.706 0 0 0 -.655-1.193c-.023-.023-.017-.059-.01-.092 0-.005 0-.01.002-.014l1.063-6.526.004-.022c.006-.05.015-.108.06-.108a1.73 1.73 0 0 0 1.16-.665c.009-.01.015-.021.027-.027.032-.015.07 0 .103.014l9.65 4.082zm-6.625 6.801-7.186 7.186 1.23-7.56.002-.01c.001-.01.003-.02.006-.029.01-.024.036-.034.061-.044l.012-.005a1.85 1.85 0 0 0 .695-.517c.024-.028.053-.055.09-.06a.09.09 0 0 1 .029 0l5.06 1.04zm-8.707 8.707-.81.81-8.955-12.942a.424.424 0 0 0 -.01-.014c-.014-.019-.029-.038-.026-.06 0-.016.011-.03.022-.042l.01-.013c.027-.04.05-.08.075-.123l.02-.035.003-.003c.014-.024.027-.047.051-.06.021-.01.05-.006.073-.001l9.921 2.046a.164.164 0 0 1 .076.033c.013.013.016.027.019.043a1.757 1.757 0 0 0 1.028 1.175c.028.014.016.045.003.078a.238.238 0 0 0 -.015.045c-.125.76-1.197 7.298-1.485 9.063zm-1.692 1.691c-.597.591-.949.904-1.347 1.03a2 2 0 0 1 -1.206 0c-.466-.148-.869-.55-1.674-1.356l-8.993-8.993 2.349-3.643c.011-.018.022-.034.04-.047.025-.018.061-.01.091 0a2.434 2.434 0 0 0 1.638-.083c.027-.01.054-.017.075.002a.19.19 0 0 1 .028.032l8.999 13.059zm-14.087-10.186-2.063-2.063 4.074-1.738a.084.084 0 0 1 .033-.007c.034 0 .054.034.072.065a2.91 2.91 0 0 0 .13.184l.013.016c.012.017.004.034-.008.05l-2.25 3.493zm-2.976-2.976-2.61-2.61c-.444-.444-.766-.766-.99-1.043l7.936 1.646a.84.84 0 0 0 .03.005c.049.008.103.017.103.063 0 .05-.059.073-.109.092l-.023.01zm-4.056-4.995a2 2 0 0 1 .09-.495c.148-.466.55-.868 1.356-1.674l3.34-3.34a2175.525 2175.525 0 0 0 4.626 6.687c.027.036.057.076.026.106-.146.161-.292.337-.395.528a.16.16 0 0 1 -.05.062c-.013.008-.027.005-.042.002h-.002l-8.949-1.877zm5.68-6.403 4.489-4.491c.423.185 1.96.834 3.333 1.414 1.04.44 1.988.84 2.286.97.03.012.057.024.07.054.008.018.004.041 0 .06a2.003 2.003 0 0 0 .523 1.828c.03.03 0 .073-.026.11l-.014.021-4.56 7.063c-.012.02-.023.037-.043.05-.024.015-.058.008-.086.001a2.274 2.274 0 0 0 -.543-.074c-.164 0-.342.03-.522.063h-.001c-.02.003-.038.007-.054-.005a.21.21 0 0 1 -.045-.051l-4.808-7.013zm5.398-5.398 5.814-5.814c.805-.805 1.208-1.208 1.674-1.355a2 2 0 0 1 1.206 0c.466.147.869.55 1.674 1.355l1.26 1.26-4.135 6.404a.155.155 0 0 1 -.041.048c-.025.017-.06.01-.09 0a2.097 2.097 0 0 0 -1.92.37c-.027.028-.067.012-.101-.003-.54-.235-4.74-2.01-5.341-2.265zm12.506-3.676 3.818 3.818-.92 5.698v.015a.135.135 0 0 1 -.008.038c-.01.02-.03.024-.05.03a1.83 1.83 0 0 0 -.548.273.154.154 0 0 0 -.02.017c-.011.012-.022.023-.04.025a.114.114 0 0 1 -.043-.007l-5.818-2.472-.011-.005c-.037-.015-.081-.033-.081-.071a2.198 2.198 0 0 0 -.31-.915c-.028-.046-.059-.094-.035-.141zm-3.932 8.606 5.454 2.31c.03.014.063.027.076.058a.106.106 0 0 1 0 .057c-.016.08-.03.171-.03.263v.153c0 .038-.039.054-.075.069l-.011.004c-.864.369-12.13 5.173-12.147 5.173s-.035 0-.052-.017c-.03-.03 0-.072.027-.11a.76.76 0 0 0 .014-.02l4.482-6.94.008-.012c.026-.042.056-.089.104-.089l.045.007c.102.014.192.027.283.027.68 0 1.31-.331 1.69-.897a.16.16 0 0 1 .034-.04c.027-.02.067-.01.098.004zm-6.246 9.185 12.28-5.237s.018 0 .035.017c.067.067.124.112.179.154l.027.017c.025.014.05.03.052.056 0 .01 0 .016-.002.025l-1.052 6.462-.004.026c-.007.05-.014.107-.061.107a1.729 1.729 0 0 0 -1.373.847l-.005.008c-.014.023-.027.045-.05.057-.021.01-.048.006-.07.001l-9.793-2.02c-.01-.002-.152-.519-.163-.52z" transform="translate(-.702)"/>
</g>
</svg>
| docs/public/assets/support/agencies/full/light/netlify.svg | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.0002944690641015768,
0.000235742365475744,
0.00017701565229799598,
0.000235742365475744,
0.00005872670590179041
]
|
{
"id": 2,
"code_window": [
"import { defineComponent, h } from 'vue'\n",
"import type { Component } from 'vue'\n",
"\n",
"const Fragment = defineComponent({\n",
" setup (_props, { slots }) {\n",
" return () => slots.default?.()\n",
" }\n",
"})\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" name: 'FragmentWrapper',\n"
],
"file_path": "packages/nuxt/src/app/components/utils.ts",
"type": "add",
"edit_start_line_idx": 4
} | /**
* This file is based on Vue.js (MIT) webpack plugins
* https://github.com/vuejs/vue/blob/dev/src/server/webpack-plugin/util.js
*/
import { logger } from '@nuxt/kit'
import type { Compiler } from 'webpack'
export const validate = (compiler: Compiler) => {
if (compiler.options.target !== 'node') {
logger.warn('webpack config `target` should be "node".')
}
if (!compiler.options.externals) {
logger.info(
'It is recommended to externalize dependencies in the server build for ' +
'better build performance.'
)
}
}
const isJSRegExp = /\.[cm]?js(\?[^.]+)?$/
export const isJS = (file: string) => isJSRegExp.test(file)
export const extractQueryPartJS = (file: string) => isJSRegExp.exec(file)?.[1]
export const isCSS = (file: string) => /\.css(\?[^.]+)?$/.test(file)
export const isHotUpdate = (file: string) => file.includes('hot-update')
| packages/webpack/src/plugins/vue/util.ts | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017701549222692847,
0.00017209250654559582,
0.0001661284186411649,
0.00017261305765714496,
0.00000394106200474198
]
|
{
"id": 3,
"code_window": [
" return _wrapIf(Transition, hasTransition && transitionProps,\n",
" wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {\n",
" onPending: () => nuxtApp.callHook('page:start', routeProps.Component),\n",
" onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }\n",
" }, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })\n",
" )).default()\n",
" }\n",
" })\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" }, { default: () => h(RouteProvider, { key, routeProps, pageKey: key, hasTransition } as {}) })\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 58
} | import { computed, defineComponent, h, provide, reactive, onMounted, nextTick, Suspense, Transition } from 'vue'
import type { DefineComponent, VNode, KeepAliveProps, TransitionProps } from 'vue'
import { RouterView } from 'vue-router'
import { defu } from 'defu'
import type { RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteLocation } from 'vue-router'
import type { RouterViewSlotProps } from './utils'
import { generateRouteKey, wrapInKeepAlive } from './utils'
import { useNuxtApp } from '#app'
import { _wrapIf } from '#app/components/utils'
// @ts-ignore
import { appPageTransition as defaultPageTransition, appKeepalive as defaultKeepaliveConfig } from '#build/nuxt.config.mjs'
export default defineComponent({
name: 'NuxtPage',
inheritAttrs: false,
props: {
name: {
type: String
},
transition: {
type: [Boolean, Object] as any as () => boolean | TransitionProps,
default: undefined
},
keepalive: {
type: [Boolean, Object] as any as () => boolean | KeepAliveProps,
default: undefined
},
route: {
type: Object as () => RouteLocationNormalized
},
pageKey: {
type: [Function, String] as unknown as () => string | ((route: RouteLocationNormalizedLoaded) => string),
default: null
}
},
setup (props, { attrs }) {
const nuxtApp = useNuxtApp()
return () => {
return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
default: (routeProps: RouterViewSlotProps) => {
if (!routeProps.Component) { return }
const key = generateRouteKey(routeProps, props.pageKey)
const done = nuxtApp.deferHydration()
const hasTransition = !!(props.transition ?? routeProps.route.meta.pageTransition ?? defaultPageTransition)
const transitionProps = hasTransition && _mergeTransitionProps([
props.transition,
routeProps.route.meta.pageTransition,
defaultPageTransition,
{ onAfterLeave: () => { nuxtApp.callHook('page:transition:finish', routeProps.Component) } }
].filter(Boolean))
return _wrapIf(Transition, hasTransition && transitionProps,
wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {
onPending: () => nuxtApp.callHook('page:start', routeProps.Component),
onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }
}, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })
)).default()
}
})
}
}
}) as DefineComponent<{
name?: string
transition?: boolean | TransitionProps
keepalive?: boolean | KeepAliveProps
route?: RouteLocationNormalized
pageKey?: string | ((route: RouteLocationNormalizedLoaded) => string)
[key: string]: any
}>
function _toArray (val: any) {
return Array.isArray(val) ? val : (val ? [val] : [])
}
function _mergeTransitionProps (routeProps: TransitionProps[]): TransitionProps {
const _props: TransitionProps[] = routeProps.map(prop => ({
...prop,
onAfterLeave: _toArray(prop.onAfterLeave)
}))
// @ts-ignore
return defu(..._props)
}
const Component = defineComponent({
// TODO: Type props
// eslint-disable-next-line vue/require-prop-types
props: ['routeProps', 'pageKey', 'hasTransition'],
setup (props) {
// Prevent reactivity when the page will be rerendered in a different suspense fork
// eslint-disable-next-line vue/no-setup-props-destructure
const previousKey = props.pageKey
// eslint-disable-next-line vue/no-setup-props-destructure
const previousRoute = props.routeProps.route
// Provide a reactive route within the page
const route = {} as RouteLocation
for (const key in props.routeProps.route) {
(route as any)[key] = computed(() => previousKey === props.pageKey ? props.routeProps.route[key] : previousRoute[key])
}
provide('_route', reactive(route))
let vnode: VNode
if (process.dev && process.client && props.hasTransition) {
onMounted(() => {
nextTick(() => {
if (['#comment', '#text'].includes(vnode?.el?.nodeName)) {
const filename = (vnode?.type as any).__file
console.warn(`[nuxt] \`${filename}\` does not have a single root node and will cause errors when navigating between routes.`)
}
})
})
}
return () => {
if (process.dev && process.client) {
vnode = h(props.routeProps.Component)
return vnode
}
return h(props.routeProps.Component)
}
}
})
| packages/nuxt/src/pages/runtime/page.ts | 1 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.9977849125862122,
0.07940565794706345,
0.0006753574125468731,
0.0023542428389191628,
0.26512718200683594
]
|
{
"id": 3,
"code_window": [
" return _wrapIf(Transition, hasTransition && transitionProps,\n",
" wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {\n",
" onPending: () => nuxtApp.callHook('page:start', routeProps.Component),\n",
" onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }\n",
" }, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })\n",
" )).default()\n",
" }\n",
" })\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" }, { default: () => h(RouteProvider, { key, routeProps, pageKey: key, hasTransition } as {}) })\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 58
} | import { buildNuxt } from '@nuxt/kit'
import { relative, resolve } from 'pathe'
import consola from 'consola'
import { clearDir } from '../utils/fs'
import { loadKit } from '../utils/kit'
import { writeTypes } from '../utils/prepare'
import { defineNuxtCommand } from './index'
export default defineNuxtCommand({
meta: {
name: 'prepare',
usage: 'npx nuxi prepare',
description: 'Prepare nuxt for development/build'
},
async invoke (args) {
process.env.NODE_ENV = process.env.NODE_ENV || 'production'
const rootDir = resolve(args._[0] || '.')
const { loadNuxt } = await loadKit(rootDir)
const nuxt = await loadNuxt({ rootDir, config: { _prepare: true } })
await clearDir(nuxt.options.buildDir)
await buildNuxt(nuxt)
await writeTypes(nuxt)
consola.success('Types generated in', relative(process.cwd(), nuxt.options.buildDir))
}
})
| packages/nuxi/src/commands/prepare.ts | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017550727352499962,
0.0001700856228126213,
0.00016479573969263583,
0.0001699538843240589,
0.000004373957381176297
]
|
{
"id": 3,
"code_window": [
" return _wrapIf(Transition, hasTransition && transitionProps,\n",
" wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {\n",
" onPending: () => nuxtApp.callHook('page:start', routeProps.Component),\n",
" onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }\n",
" }, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })\n",
" )).default()\n",
" }\n",
" })\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" }, { default: () => h(RouteProvider, { key, routeProps, pageKey: key, hasTransition } as {}) })\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 58
} | import { existsSync, readdirSync } from 'node:fs'
import { defineNuxtModule, addTemplate, addPlugin, addVitePlugin, addWebpackPlugin, findPath, addComponent, updateTemplates } from '@nuxt/kit'
import { relative, resolve } from 'pathe'
import { genString, genImport, genObjectFromRawEntries } from 'knitwork'
import escapeRE from 'escape-string-regexp'
import type { NuxtApp, NuxtPage } from '@nuxt/schema'
import { joinURL } from 'ufo'
import { distDir } from '../dirs'
import { resolvePagesRoutes, normalizeRoutes } from './utils'
import type { PageMetaPluginOptions } from './page-meta'
import { PageMetaPlugin } from './page-meta'
export default defineNuxtModule({
meta: {
name: 'pages'
},
setup (_options, nuxt) {
const pagesDirs = nuxt.options._layers.map(
layer => resolve(layer.config.srcDir, layer.config.dir?.pages || 'pages')
)
// Disable module (and use universal router) if pages dir do not exists or user has disabled it
const isNonEmptyDir = (dir: string) => existsSync(dir) && readdirSync(dir).length
const isPagesEnabled = () => {
if (typeof nuxt.options.pages === 'boolean') {
return nuxt.options.pages
}
if (nuxt.options._layers.some(layer => existsSync(resolve(layer.config.srcDir, 'app/router.options.ts')))) {
return true
}
if (pagesDirs.some(dir => isNonEmptyDir(dir))) {
return true
}
return false
}
nuxt.options.pages = isPagesEnabled()
if (!nuxt.options.pages) {
addPlugin(resolve(distDir, 'app/plugins/router'))
addTemplate({
filename: 'pages.mjs',
getContents: () => 'export { useRoute } from \'#app\''
})
addComponent({
name: 'NuxtPage',
filePath: resolve(distDir, 'pages/runtime/page-placeholder')
})
return
}
const runtimeDir = resolve(distDir, 'pages/runtime')
// Add $router types
nuxt.hook('prepare:types', ({ references }) => {
references.push({ types: 'vue-router' })
})
// Add vue-router route guard imports
nuxt.hook('imports:sources', (sources) => {
const routerImports = sources.find(s => s.from === '#app' && s.imports.includes('onBeforeRouteLeave'))
if (routerImports) {
routerImports.from = 'vue-router'
}
})
// Regenerate templates when adding or removing pages
nuxt.hook('builder:watch', async (event, path) => {
const dirs = [
nuxt.options.dir.pages,
nuxt.options.dir.layouts,
nuxt.options.dir.middleware
].filter(Boolean)
const pathPattern = new RegExp(`(^|\\/)(${dirs.map(escapeRE).join('|')})/`)
if (event !== 'change' && path.match(pathPattern)) {
await updateTemplates({
filter: template => template.filename === 'routes.mjs'
})
}
})
nuxt.hook('app:resolve', (app) => {
// Add default layout for pages
if (app.mainComponent!.includes('@nuxt/ui-templates')) {
app.mainComponent = resolve(runtimeDir, 'app.vue')
}
app.middleware.unshift({
name: 'validate',
path: resolve(runtimeDir, 'validate'),
global: true
})
})
// Prerender all non-dynamic page routes when generating app
if (!nuxt.options.dev && nuxt.options._generate) {
const prerenderRoutes = new Set<string>()
nuxt.hook('modules:done', () => {
nuxt.hook('pages:extend', (pages) => {
prerenderRoutes.clear()
const processPages = (pages: NuxtPage[], currentPath = '/') => {
for (const page of pages) {
// Add root of optional dynamic paths and catchalls
if (page.path.match(/^\/?:.*(\?|\(\.\*\)\*)$/) && !page.children?.length) { prerenderRoutes.add(currentPath) }
// Skip dynamic paths
if (page.path.includes(':')) { continue }
const route = joinURL(currentPath, page.path)
prerenderRoutes.add(route)
if (page.children) { processPages(page.children, route) }
}
}
processPages(pages)
})
})
nuxt.hook('nitro:build:before', (nitro) => {
for (const route of nitro.options.prerender.routes || []) {
// Skip default route value as we only generate it if it is already
// in the detected routes from `~/pages`.
if (route === '/') { continue }
prerenderRoutes.add(route)
}
nitro.options.prerender.routes = Array.from(prerenderRoutes)
})
}
nuxt.hook('imports:extend', (imports) => {
imports.push(
{ name: 'definePageMeta', as: 'definePageMeta', from: resolve(runtimeDir, 'composables') },
{ name: 'useLink', as: 'useLink', from: 'vue-router' }
)
})
// Extract macros from pages
const pageMetaOptions: PageMetaPluginOptions = {
dev: nuxt.options.dev,
sourcemap: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client,
dirs: nuxt.options._layers.map(
layer => resolve(layer.config.srcDir, layer.config.dir?.pages || 'pages')
)
}
addVitePlugin(PageMetaPlugin.vite(pageMetaOptions))
addWebpackPlugin(PageMetaPlugin.webpack(pageMetaOptions))
// Add router plugin
addPlugin(resolve(runtimeDir, 'router'))
const getSources = (pages: NuxtPage[]): string[] => pages.flatMap(p =>
[relative(nuxt.options.srcDir, p.file), ...getSources(p.children || [])]
)
// Do not prefetch page chunks
nuxt.hook('build:manifest', async (manifest) => {
const pages = await resolvePagesRoutes()
await nuxt.callHook('pages:extend', pages)
const sourceFiles = getSources(pages)
for (const key in manifest) {
if (manifest[key].isEntry) {
manifest[key].dynamicImports =
manifest[key].dynamicImports?.filter(i => !sourceFiles.includes(i))
}
}
})
// Add routes template
addTemplate({
filename: 'routes.mjs',
async getContents () {
const pages = await resolvePagesRoutes()
await nuxt.callHook('pages:extend', pages)
const { routes, imports } = normalizeRoutes(pages)
return [...imports, `export default ${routes}`].join('\n')
}
})
// Add vue-router import for `<NuxtLayout>` integration
addTemplate({
filename: 'pages.mjs',
getContents: () => 'export { useRoute } from \'vue-router\''
})
// Optimize vue-router to ensure we share the same injection symbol
nuxt.options.vite.optimizeDeps = nuxt.options.vite.optimizeDeps || {}
nuxt.options.vite.optimizeDeps.include = nuxt.options.vite.optimizeDeps.include || []
nuxt.options.vite.optimizeDeps.include.push('vue-router')
// Add router options template
addTemplate({
filename: 'router.options.mjs',
getContents: async () => {
// Scan and register app/router.options files
const routerOptionsFiles = (await Promise.all(nuxt.options._layers.map(
async layer => await findPath(resolve(layer.config.srcDir, 'app/router.options'))
))).filter(Boolean) as string[]
// Add default options
routerOptionsFiles.push(resolve(runtimeDir, 'router.options'))
const configRouterOptions = genObjectFromRawEntries(Object.entries(nuxt.options.router.options)
.map(([key, value]) => [key, genString(value as string)]))
return [
...routerOptionsFiles.map((file, index) => genImport(file, `routerOptions${index}`)),
`const configRouterOptions = ${configRouterOptions}`,
'export default {',
'...configRouterOptions,',
// We need to reverse spreading order to respect layers priority
...routerOptionsFiles.map((_, index) => `...routerOptions${index},`).reverse(),
'}'
].join('\n')
}
})
addTemplate({
filename: 'types/middleware.d.ts',
getContents: ({ app }: { app: NuxtApp }) => {
const composablesFile = resolve(runtimeDir, 'composables')
const namedMiddleware = app.middleware.filter(mw => !mw.global)
return [
'import type { NavigationGuard } from \'vue-router\'',
`export type MiddlewareKey = ${namedMiddleware.map(mw => genString(mw.name)).join(' | ') || 'string'}`,
`declare module ${genString(composablesFile)} {`,
' interface PageMeta {',
' middleware?: MiddlewareKey | NavigationGuard | Array<MiddlewareKey | NavigationGuard>',
' }',
'}'
].join('\n')
}
})
addTemplate({
filename: 'types/layouts.d.ts',
getContents: ({ app }: { app: NuxtApp }) => {
const composablesFile = resolve(runtimeDir, 'composables')
return [
'import { ComputedRef, Ref } from \'vue\'',
`export type LayoutKey = ${Object.keys(app.layouts).map(name => genString(name)).join(' | ') || 'string'}`,
`declare module ${genString(composablesFile)} {`,
' interface PageMeta {',
' layout?: false | LayoutKey | Ref<LayoutKey> | ComputedRef<LayoutKey>',
' }',
'}'
].join('\n')
}
})
// Add <NuxtPage>
addComponent({
name: 'NuxtPage',
filePath: resolve(distDir, 'pages/runtime/page')
})
// Add declarations for middleware keys
nuxt.hook('prepare:types', ({ references }) => {
references.push({ path: resolve(nuxt.options.buildDir, 'types/middleware.d.ts') })
references.push({ path: resolve(nuxt.options.buildDir, 'types/layouts.d.ts') })
})
}
})
| packages/nuxt/src/pages/module.ts | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00023933884222060442,
0.0001696360413916409,
0.0001600481482455507,
0.00016626319848001003,
0.00001484823769715149
]
|
{
"id": 3,
"code_window": [
" return _wrapIf(Transition, hasTransition && transitionProps,\n",
" wrapInKeepAlive(props.keepalive ?? routeProps.route.meta.keepalive ?? (defaultKeepaliveConfig as KeepAliveProps), h(Suspense, {\n",
" onPending: () => nuxtApp.callHook('page:start', routeProps.Component),\n",
" onResolve: () => { nextTick(() => nuxtApp.callHook('page:finish', routeProps.Component).finally(done)) }\n",
" }, { default: () => h(Component, { key, routeProps, pageKey: key, hasTransition } as {}) })\n",
" )).default()\n",
" }\n",
" })\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" }, { default: () => h(RouteProvider, { key, routeProps, pageKey: key, hasTransition } as {}) })\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 58
} | <template>
<div>
About
</div>
</template>
| examples/routing/pages/pages/about.vue | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.000168878206750378,
0.000168878206750378,
0.000168878206750378,
0.000168878206750378,
0
]
|
{
"id": 4,
"code_window": [
" }))\n",
" // @ts-ignore\n",
" return defu(..._props)\n",
"}\n",
"\n",
"const Component = defineComponent({\n",
" // TODO: Type props\n",
" // eslint-disable-next-line vue/require-prop-types\n",
" props: ['routeProps', 'pageKey', 'hasTransition'],\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
"const RouteProvider = defineComponent({\n",
" name: 'RouteProvider',\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 86
} | import { defineComponent, h } from 'vue'
import type { Component } from 'vue'
const Fragment = defineComponent({
setup (_props, { slots }) {
return () => slots.default?.()
}
})
/**
* Internal utility
*
* @private
*/
export const _wrapIf = (component: Component, props: any, slots: any) => {
return { default: () => props ? h(component, props === true ? {} : props, slots) : h(Fragment, {}, slots) }
}
| packages/nuxt/src/app/components/utils.ts | 1 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.9972879886627197,
0.9970208406448364,
0.9967537522315979,
0.9970208406448364,
0.0002671182155609131
]
|
{
"id": 4,
"code_window": [
" }))\n",
" // @ts-ignore\n",
" return defu(..._props)\n",
"}\n",
"\n",
"const Component = defineComponent({\n",
" // TODO: Type props\n",
" // eslint-disable-next-line vue/require-prop-types\n",
" props: ['routeProps', 'pageKey', 'hasTransition'],\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
"const RouteProvider = defineComponent({\n",
" name: 'RouteProvider',\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 86
} | <template>
<div>
fixed-keyed-child-parent
<NuxtPage />
</div>
</template>
| test/fixtures/basic/pages/fixed-keyed-child-parent.vue | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017340088379569352,
0.00017340088379569352,
0.00017340088379569352,
0.00017340088379569352,
0
]
|
{
"id": 4,
"code_window": [
" }))\n",
" // @ts-ignore\n",
" return defu(..._props)\n",
"}\n",
"\n",
"const Component = defineComponent({\n",
" // TODO: Type props\n",
" // eslint-disable-next-line vue/require-prop-types\n",
" props: ['routeProps', 'pageKey', 'hasTransition'],\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
"const RouteProvider = defineComponent({\n",
" name: 'RouteProvider',\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 86
} | <template>
<div>
Single
<div>
{{ data }} - {{ data2 }}
</div>
</div>
</template>
<script setup lang="ts">
const { data, refresh } = await useCounter()
const { data: data2, refresh: refresh2 } = await useCounter()
let initial = data.value!.count
// Refresh on client and server side
await refresh()
if (data.value!.count !== initial + 1) {
throw new Error('Data not refreshed?' + data.value!.count + ' : ' + data2.value!.count)
}
if (data.value!.count !== data2.value!.count) {
throw new Error('AsyncData not synchronised')
}
initial = data.value!.count
await refresh2()
if (data.value!.count !== initial + 1) {
throw new Error('data2 refresh not syncronised?')
}
if (data.value!.count !== data2.value!.count) {
throw new Error('AsyncData not synchronised')
}
</script>
| test/fixtures/basic/pages/useAsyncData/refresh.vue | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00017498410306870937,
0.00017275910067837685,
0.00016945097013376653,
0.00017330066475551575,
0.0000021995326733303955
]
|
{
"id": 4,
"code_window": [
" }))\n",
" // @ts-ignore\n",
" return defu(..._props)\n",
"}\n",
"\n",
"const Component = defineComponent({\n",
" // TODO: Type props\n",
" // eslint-disable-next-line vue/require-prop-types\n",
" props: ['routeProps', 'pageKey', 'hasTransition'],\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
"const RouteProvider = defineComponent({\n",
" name: 'RouteProvider',\n"
],
"file_path": "packages/nuxt/src/pages/runtime/page.ts",
"type": "replace",
"edit_start_line_idx": 86
} | <svg width="52" height="58" viewBox="0 0 52 58" fill="none" xmlns="http://www.w3.org/2000/svg">
<g clip-path="url(#clip0_1958_63141)">
<path d="M5.508 15.3227L5.50802 15.3227L5.51516 15.3182L22.8027 4.37921C24.1138 3.57184 25.7379 3.54018 27.0673 4.29161L27.0715 4.29396L45.6066 14.6133C45.6073 14.6138 45.608 14.6142 45.6087 14.6146C46.9303 15.3626 47.7712 16.7791 47.8043 18.3448L47.9155 38.5289H47.9154L47.9156 38.5397C47.9468 40.1033 47.1694 41.5622 45.8798 42.3851L28.3284 53.5843C27.0089 54.4262 25.356 54.4717 24.0056 53.7084L5.8819 43.4643C4.45653 42.6586 3.40665 41.1507 3.41657 39.6072H3.41659V39.6024L3.41666 19.0833C3.41666 19.0825 3.41667 19.0817 3.41667 19.081C3.42739 17.5381 4.22435 16.1148 5.508 15.3227Z" fill="white" stroke="url(#paint0_linear_1958_63141)" stroke-width="1.5"/>
<path d="M34.565 27.6407C34.4478 27.4813 34.2948 27.3517 34.1185 27.2621C33.9421 27.1726 33.7472 27.1256 33.5494 27.125H32.5416V25.875C32.5416 25.5435 32.4099 25.2256 32.1754 24.9912C31.941 24.7567 31.6231 24.625 31.2916 24.625H25.8775L23.7056 23C23.4903 22.8357 23.2265 22.7477 22.9556 22.75H18.7916C18.46 22.75 18.1421 22.8817 17.9077 23.1162C17.6733 23.3506 17.5416 23.6685 17.5416 24V35.25C17.5405 35.3324 17.556 35.4142 17.587 35.4905C17.618 35.5668 17.664 35.6361 17.7223 35.6943C17.7805 35.7526 17.8498 35.7986 17.9261 35.8296C18.0024 35.8606 18.0842 35.8761 18.1666 35.875H31.9166C32.0482 35.8751 32.1764 35.8335 32.283 35.7564C32.3896 35.6792 32.4692 35.5704 32.5103 35.4454L34.7369 28.7735C34.7987 28.5844 34.8154 28.3834 34.7855 28.1867C34.7557 27.9899 34.6801 27.8029 34.565 27.6407ZM22.9556 24L25.1275 25.625C25.3428 25.7894 25.6067 25.8774 25.8775 25.875H31.2916V27.125H21.1197C20.8574 27.1245 20.6017 27.2064 20.3885 27.3592C20.1754 27.5121 20.0158 27.728 19.9322 27.9766L18.7916 31.3985V24H22.9556ZM31.4634 34.625H19.0337L21.1197 28.375H33.5494L31.4634 34.625Z" fill="url(#paint1_linear_1958_63141)"/>
</g>
<defs>
<linearGradient id="paint0_linear_1958_63141" x1="3.11754" y1="18.9481" x2="48.8405" y2="41.3679" gradientUnits="userSpaceOnUse">
<stop stop-color="#00DC82"/>
<stop offset="1" stop-color="#003F25"/>
</linearGradient>
<linearGradient id="paint1_linear_1958_63141" x1="17.4934" y1="25.5549" x2="32.3706" y2="36.0783" gradientUnits="userSpaceOnUse">
<stop stop-color="#00DC82"/>
<stop offset="1" stop-color="#003F25"/>
</linearGradient>
<clipPath id="clip0_1958_63141">
<rect width="51" height="58" fill="white" transform="translate(0.666504)"/>
</clipPath>
</defs>
</svg>
| docs/public/assets/docs/getting-started/views/docs-landing/directory-structure-light.svg | 0 | https://github.com/nuxt/nuxt/commit/0db3c6373a72e218baddfc3626695173da103a88 | [
0.00080466503277421,
0.000490057107526809,
0.00017544922593515366,
0.000490057107526809,
0.00031460789614357054
]
|
{
"id": 0,
"code_window": [
"import SidebarStories from './SidebarStories';\n",
"\n",
"const Heading = styled(SidebarHeading)({\n",
" padding: '20px 20px 10px',\n",
"});\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" padding: '20px 20px 12px',\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 9
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9982970356941223,
0.14487560093402863,
0.0001852377608884126,
0.0008845001575537026,
0.34842801094055176
]
|
{
"id": 0,
"code_window": [
"import SidebarStories from './SidebarStories';\n",
"\n",
"const Heading = styled(SidebarHeading)({\n",
" padding: '20px 20px 10px',\n",
"});\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" padding: '20px 20px 12px',\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 9
} | import { storiesOf, moduleMetadata } from '@storybook/angular';
import { withKnobs, text } from '@storybook/addon-knobs';
import { DummyService } from './moduleMetadata/dummy.service';
import { ServiceComponent } from './moduleMetadata/service.component';
storiesOf('Custom|Providers', module)
.addDecorator(
moduleMetadata({
imports: [],
schemas: [],
declarations: [],
providers: [DummyService],
})
)
.add('Simple', () => ({
component: ServiceComponent,
props: {
name: 'Static name',
},
}))
.addDecorator(withKnobs)
.add('With knobs', () => {
const name = text('name', 'Dynamic knob');
return {
component: ServiceComponent,
props: {
name,
},
};
});
| examples/angular-cli/src/stories/custom-providers.stories.ts | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017742172349244356,
0.00017644076433498412,
0.00017573217337485403,
0.00017630457296036184,
6.138496360108547e-7
]
|
{
"id": 0,
"code_window": [
"import SidebarStories from './SidebarStories';\n",
"\n",
"const Heading = styled(SidebarHeading)({\n",
" padding: '20px 20px 10px',\n",
"});\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" padding: '20px 20px 12px',\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 9
} | // This optional code is used to register a service worker.
// register() is not called by default.
// This lets the app load faster on subsequent visits in production, and gives
// it offline capabilities. However, it also means that developers (and users)
// will only see deployed updates on subsequent visits to a page, after all the
// existing tabs open on the page have been closed, since previously cached
// resources are updated in the background.
// To learn more about the benefits of this model and instructions on how to
// opt-in, read http://bit.ly/CRA-PWA
const isLocalhost = Boolean(
window.location.hostname === 'localhost' ||
// [::1] is the IPv6 localhost address.
window.location.hostname === '[::1]' ||
// 127.0.0.1/8 is considered localhost for IPv4.
window.location.hostname.match(
/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
)
);
export function register(config) {
if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
// The URL constructor is available in all browsers that support SW.
const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href);
if (publicUrl.origin !== window.location.origin) {
// Our service worker won't work if PUBLIC_URL is on a different origin
// from what our page is served on. This might happen if a CDN is used to
// serve assets; see https://github.com/facebook/create-react-app/issues/2374
return;
}
window.addEventListener('load', () => {
const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;
if (isLocalhost) {
// This is running on localhost. Let's check if a service worker still exists or not.
checkValidServiceWorker(swUrl, config);
// Add some additional logging to localhost, pointing developers to the
// service worker/PWA documentation.
navigator.serviceWorker.ready.then(() => {
console.log(
'This web app is being served cache-first by a service ' +
'worker. To learn more, visit http://bit.ly/CRA-PWA'
);
});
} else {
// Is not localhost. Just register service worker
registerValidSW(swUrl, config);
}
});
}
}
function registerValidSW(swUrl, config) {
navigator.serviceWorker
.register(swUrl)
.then(registration => {
registration.onupdatefound = () => {
const installingWorker = registration.installing;
if (installingWorker == null) {
return;
}
installingWorker.onstatechange = () => {
if (installingWorker.state === 'installed') {
if (navigator.serviceWorker.controller) {
// At this point, the updated precached content has been fetched,
// but the previous service worker will still serve the older
// content until all client tabs are closed.
console.log(
'New content is available and will be used when all ' +
'tabs for this page are closed. See http://bit.ly/CRA-PWA.'
);
// Execute callback
if (config && config.onUpdate) {
config.onUpdate(registration);
}
} else {
// At this point, everything has been precached.
// It's the perfect time to display a
// "Content is cached for offline use." message.
console.log('Content is cached for offline use.');
// Execute callback
if (config && config.onSuccess) {
config.onSuccess(registration);
}
}
}
};
};
})
.catch(error => {
console.error('Error during service worker registration:', error);
});
}
function checkValidServiceWorker(swUrl, config) {
// Check if the service worker can be found. If it can't reload the page.
fetch(swUrl)
.then(response => {
// Ensure service worker exists, and that we really are getting a JS file.
const contentType = response.headers.get('content-type');
if (
response.status === 404 ||
(contentType != null && contentType.indexOf('javascript') === -1)
) {
// No service worker found. Probably a different app. Reload the page.
navigator.serviceWorker.ready.then(registration => {
registration.unregister().then(() => {
window.location.reload();
});
});
} else {
// Service worker found. Proceed as normal.
registerValidSW(swUrl, config);
}
})
.catch(() => {
console.log(
'No internet connection found. App is running in offline mode.'
);
});
}
export function unregister() {
if ('serviceWorker' in navigator) {
navigator.serviceWorker.ready.then(registration => {
registration.unregister();
});
}
}
| lib/cli/test/fixtures/react_scripts_v2_forked/src/serviceWorker.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017492838378529996,
0.00017015112098306417,
0.00016679347027093172,
0.00017002261301968247,
0.000002350966497033369
]
|
{
"id": 0,
"code_window": [
"import SidebarStories from './SidebarStories';\n",
"\n",
"const Heading = styled(SidebarHeading)({\n",
" padding: '20px 20px 10px',\n",
"});\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" padding: '20px 20px 12px',\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 9
} | module.exports = {
printWidth: 100,
tabWidth: 2,
bracketSpacing: true,
trailingComma: 'es5',
singleQuote: true,
overrides: [
{
files: '*.html',
options: { parser: 'babel' },
},
],
};
| prettier.config.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017829697753768414,
0.00017554228543303907,
0.00017278757877647877,
0.00017554228543303907,
0.0000027546993806026876
]
|
{
"id": 1,
"code_window": [
"});\n",
"\n",
"const Container = styled.nav({\n",
" position: 'absolute',\n",
" zIndex: 1,\n"
],
"labels": [
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"const Stories = styled(SidebarStories)(({ loading }) => (loading ? { marginTop: 8 } : {}));\n",
"\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 12
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9980619549751282,
0.283463716506958,
0.00016699811385478824,
0.002656316850334406,
0.44597724080085754
]
|
{
"id": 1,
"code_window": [
"});\n",
"\n",
"const Container = styled.nav({\n",
" position: 'absolute',\n",
" zIndex: 1,\n"
],
"labels": [
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"const Stories = styled(SidebarStories)(({ loading }) => (loading ? { marginTop: 8 } : {}));\n",
"\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 12
} | {
"short_name": "React App",
"name": "Create React App Sample",
"icons": [
{
"src": "favicon.ico",
"sizes": "64x64 32x32 24x24 16x16",
"type": "image/x-icon"
}
],
"start_url": ".",
"display": "standalone",
"theme_color": "#000000",
"background_color": "#ffffff"
}
| lib/cli/test/fixtures/react_scripts_v2/public/manifest.json | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017213457613252103,
0.00017112636123783886,
0.00017011813179124147,
0.00017112636123783886,
0.0000010082221706397831
]
|
{
"id": 1,
"code_window": [
"});\n",
"\n",
"const Container = styled.nav({\n",
" position: 'absolute',\n",
" zIndex: 1,\n"
],
"labels": [
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"const Stories = styled(SidebarStories)(({ loading }) => (loading ? { marginTop: 8 } : {}));\n",
"\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 12
} | import { Template } from 'meteor/templating';
import { ReactiveVar } from 'meteor/reactive-var';
import './main.html';
Template.hello.onCreated(function helloOnCreated() {
// counter starts at 0
this.counter = new ReactiveVar(0);
});
Template.hello.helpers({
counter() {
return Template.instance().counter.get();
},
});
Template.hello.events({
'click button'(event, instance) {
// increment the counter when button is clicked
instance.counter.set(instance.counter.get() + 1);
},
});
| lib/cli/test/fixtures/meteor/client/main.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017311013652943075,
0.0001707685150904581,
0.00016749519272707403,
0.00017170017235912383,
0.000002385079824307468
]
|
{
"id": 1,
"code_window": [
"});\n",
"\n",
"const Container = styled.nav({\n",
" position: 'absolute',\n",
" zIndex: 1,\n"
],
"labels": [
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"const Stories = styled(SidebarStories)(({ loading }) => (loading ? { marginTop: 8 } : {}));\n",
"\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 12
} | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
# dependencies
/node_modules
/.pnp
.pnp.js
# testing
/coverage
# production
/build
# misc
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local
npm-debug.log*
yarn-debug.log*
yarn-error.log*
| lib/cli/test/fixtures/react_scripts_v2/.gitignore | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017214048421010375,
0.00017008591385092586,
0.0001680030400166288,
0.00017011423187796026,
0.000001689223154244246
]
|
{
"id": 2,
"code_window": [
" zIndex: 2,\n",
"});\n",
"\n",
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (\n",
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted, loading }) => (\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 39
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9984018206596375,
0.7097181677818298,
0.00043722495320253074,
0.996060311794281,
0.4475635290145874
]
|
{
"id": 2,
"code_window": [
" zIndex: 2,\n",
"});\n",
"\n",
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (\n",
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted, loading }) => (\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 39
} | module.exports = {
printWidth: 100,
tabWidth: 2,
bracketSpacing: true,
trailingComma: 'es5',
singleQuote: true,
overrides: [
{
files: '*.html',
options: { parser: 'babel' },
},
],
};
| prettier.config.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017380031931679696,
0.00017293922428507358,
0.0001720781292533502,
0.00017293922428507358,
8.610950317233801e-7
]
|
{
"id": 2,
"code_window": [
" zIndex: 2,\n",
"});\n",
"\n",
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (\n",
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted, loading }) => (\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 39
} | node_modules/
| lib/cli/test/fixtures/meteor/.gitignore | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017581330030225217,
0.00017581330030225217,
0.00017581330030225217,
0.00017581330030225217,
0
]
|
{
"id": 2,
"code_window": [
" zIndex: 2,\n",
"});\n",
"\n",
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (\n",
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
"const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted, loading }) => (\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 39
} | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Storyshots Custom|Style Default 1`] = `
<storybook-dynamic-app-root
cfr={[Function CodegenComponentFactoryResolver]}
data={[Function Object]}
target={[Function ViewContainerRef_]}
>
<ng-component>
<storybook-button-component
_nghost-c11=""
ng-reflect-text="Button with custom styles"
>
<button
_ngcontent-c11=""
>
Button with custom styles
</button>
</storybook-button-component>
</ng-component>
</storybook-dynamic-app-root>
`;
exports[`Storyshots Custom|Style With Knobs 1`] = `
<storybook-dynamic-app-root
cfr={[Function CodegenComponentFactoryResolver]}
data={[Function Object]}
target={[Function ViewContainerRef_]}
>
<ng-component>
<storybook-button-component
_nghost-c12=""
ng-reflect-text="Button with custom styles"
>
<button
_ngcontent-c12=""
>
Button with custom styles
</button>
</storybook-button-component>
</ng-component>
</storybook-dynamic-app-root>
`;
| examples/angular-cli/src/stories/__snapshots__/custom-styles.stories.storyshot | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017087471496779472,
0.00016743075684644282,
0.0001647022581892088,
0.00016654713544994593,
0.0000021472897060448304
]
|
{
"id": 3,
"code_window": [
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n",
" <SidebarStories stories={stories} storyId={storyId} />\n",
"\n",
" <Foot>\n",
" <NotificationListSpacer notifications={notifications} />\n",
" </Foot>\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" <Stories stories={stories} storyId={storyId} loading={loading} />\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 42
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled, withTheme } from '@storybook/theming';
import { StorybookLogo } from '@storybook/components';
import Menu from '../menu/Menu';
const BrandArea = styled.div(({ theme }) => ({
fontSize: `${theme.typography.size.s2}px`,
fontWeight: theme.typography.weight.bold,
}));
const Logo = styled(StorybookLogo)({
width: 'auto',
height: 24,
display: 'block',
});
const LogoLink = styled.a({
display: 'inline-block',
color: 'inherit',
textDecoration: 'none',
});
const Head = styled.div({
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
});
const Brand = withTheme(({ theme: { brand } }) => (
<BrandArea>
{brand || (
<LogoLink href="./">
<Logo />
</LogoLink>
)}
</BrandArea>
));
export default function SidebarHeading({ menuHighlighted, menu, ...props }) {
return (
<Head {...props}>
<Brand />
<Menu highlighted={menuHighlighted} menuItems={menu} />
</Head>
);
}
SidebarHeading.propTypes = {
menuHighlighted: PropTypes.bool,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
};
SidebarHeading.defaultProps = {
menuHighlighted: false,
};
| lib/ui/src/components/sidebar/SidebarHeading.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.005005418322980404,
0.0012918049469590187,
0.00016370318189729005,
0.0001753619289956987,
0.0017993684159591794
]
|
{
"id": 3,
"code_window": [
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n",
" <SidebarStories stories={stories} storyId={storyId} />\n",
"\n",
" <Foot>\n",
" <NotificationListSpacer notifications={notifications} />\n",
" </Foot>\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" <Stories stories={stories} storyId={storyId} loading={loading} />\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 42
} | // FIXME: @igor-dv
// import React from 'react';
// import { storiesOf } from '@storybook/react';
// import { ReactComponent as Logo } from '../logo.svg';
//
// storiesOf('CRA', module).add('Svgr', () => <Logo />);
| examples/cra-kitchen-sink/src/stories/cra-svgr.stories.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0001723558088997379,
0.0001723558088997379,
0.0001723558088997379,
0.0001723558088997379,
0
]
|
{
"id": 3,
"code_window": [
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n",
" <SidebarStories stories={stories} storyId={storyId} />\n",
"\n",
" <Foot>\n",
" <NotificationListSpacer notifications={notifications} />\n",
" </Foot>\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" <Stories stories={stories} storyId={storyId} loading={loading} />\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 42
} | import '@storybook/addon-storysource/register';
import '@storybook/addon-actions/register';
import '@storybook/addon-links/register';
import '@storybook/addon-notes/register';
import '@storybook/addon-knobs/register';
import '@storybook/addon-viewport/register';
import '@storybook/addon-options/register';
import '@storybook/addon-backgrounds/register';
| examples/mithril-kitchen-sink/.storybook/addons.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017447161371819675,
0.00017447161371819675,
0.00017447161371819675,
0.00017447161371819675,
0
]
|
{
"id": 3,
"code_window": [
" <Container className=\"container\">\n",
" <Heading menuHighlighted={menuHighlighted} menu={menu} />\n",
" <SidebarStories stories={stories} storyId={storyId} />\n",
"\n",
" <Foot>\n",
" <NotificationListSpacer notifications={notifications} />\n",
" </Foot>\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" <Stories stories={stories} storyId={storyId} loading={loading} />\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "replace",
"edit_start_line_idx": 42
} | import React from 'react';
import { storiesOf } from '@storybook/react';
import centered from '@storybook/addon-centered/react';
import BaseButton from '../components/BaseButton';
storiesOf('Addons|Centered', module)
.addDecorator(centered)
.add('story 1', () => <BaseButton label="This story should be centered" />);
| examples/official-storybook/stories/addon-centered.stories.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017064351413864642,
0.00017064351413864642,
0.00017064351413864642,
0.00017064351413864642,
0
]
|
{
"id": 4,
"code_window": [
" stories: PropTypes.shape({}).isRequired,\n",
" storyId: PropTypes.string,\n",
" notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menuHighlighted: PropTypes.bool,\n",
"};\n",
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: PropTypes.bool,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 60
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9925547242164612,
0.14439566433429718,
0.00016848767700139433,
0.0027235900051891804,
0.34627264738082886
]
|
{
"id": 4,
"code_window": [
" stories: PropTypes.shape({}).isRequired,\n",
" storyId: PropTypes.string,\n",
" notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menuHighlighted: PropTypes.bool,\n",
"};\n",
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: PropTypes.bool,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 60
} | /* You can add global styles to this file, and also import other style files */
.css-rules-warning {
display: none;
}
| examples/angular-cli/src/styles.css | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017627138004172593,
0.00017627138004172593,
0.00017627138004172593,
0.00017627138004172593,
0
]
|
{
"id": 4,
"code_window": [
" stories: PropTypes.shape({}).isRequired,\n",
" storyId: PropTypes.string,\n",
" notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menuHighlighted: PropTypes.bool,\n",
"};\n",
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: PropTypes.bool,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 60
} | import m from 'mithril';
const BaseButton = {
view: ({ attrs }) =>
m(
'button',
{ disabled: attrs.disabled, onclick: attrs.onclick, style: attrs.style },
attrs.label
),
};
export default BaseButton;
| examples/mithril-kitchen-sink/src/BaseButton.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017447561549488455,
0.0001735508267302066,
0.00017262603796552867,
0.0001735508267302066,
9.247887646779418e-7
]
|
{
"id": 4,
"code_window": [
" stories: PropTypes.shape({}).isRequired,\n",
" storyId: PropTypes.string,\n",
" notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,\n",
" menuHighlighted: PropTypes.bool,\n",
"};\n",
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: PropTypes.bool,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 60
} | import { styled } from '@storybook/theming';
const Svg = styled.svg(({ inline }) =>
inline
? {
display: 'inline-block',
}
: {
display: 'block',
}
);
Svg.displayName = 'Svg';
export { Svg as default };
| lib/components/src/icon/svg.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017815610044635832,
0.00017769895202945918,
0.00017724180361256003,
0.00017769895202945918,
4.5714841689914465e-7
]
|
{
"id": 5,
"code_window": [
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n",
" menuHighlighted: false,\n",
"};\n",
"Sidebar.displayName = 'Sidebar';\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: false,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 64
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9958678483963013,
0.14410506188869476,
0.000175107445102185,
0.0007449413533322513,
0.3477403223514557
]
|
{
"id": 5,
"code_window": [
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n",
" menuHighlighted: false,\n",
"};\n",
"Sidebar.displayName = 'Sidebar';\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: false,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 64
} | SKIP_PREFLIGHT_CHECK=true
NODE_PATH=src | examples/cra-kitchen-sink/.env | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017655512783676386,
0.00017655512783676386,
0.00017655512783676386,
0.00017655512783676386,
0
]
|
{
"id": 5,
"code_window": [
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n",
" menuHighlighted: false,\n",
"};\n",
"Sidebar.displayName = 'Sidebar';\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: false,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 64
} | {
"name": "react-project-fixture",
"version": "1.0.0",
"license": "MIT",
"main": "index.js",
"scripts": {
"build": "babel index.js -d dist"
},
"devDependencies": {
"@babel/cli": "7.1.0",
"@babel/preset-env": "7.1.0",
"@babel/preset-react": "7.0.0",
"react": "^15.6.1",
"react-dom": "^15.6.1"
},
"peerDependencies": {
"react": "*",
"react-dom": "*"
}
}
| lib/cli/test/fixtures/react_project/package.json | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00018234364688396454,
0.00017747498350217938,
0.0001745047338772565,
0.0001755765697453171,
0.0000034703621167864185
]
|
{
"id": 5,
"code_window": [
"Sidebar.defaultProps = {\n",
" storyId: undefined,\n",
" menuHighlighted: false,\n",
"};\n",
"Sidebar.displayName = 'Sidebar';\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
" loading: false,\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.js",
"type": "add",
"edit_start_line_idx": 64
} | export function webpack(config) {
return {
...config,
module: {
...config.module,
rules: [
...config.module.rules,
{
test: /\.tag$/,
use: [
{
loader: require.resolve('riot-tag-loader'),
},
],
},
],
},
resolve: {
...config.resolve,
alias: {
...config.resolve.alias,
'riot-compiler': 'riot-compiler/dist/es6.compiler',
},
},
};
}
| app/riot/src/server/framework-preset-riot.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017398617637809366,
0.00017162652511615306,
0.0001693154772510752,
0.00017157792171929032,
0.0000019071145516136312
]
|
{
"id": 6,
"code_window": [
" <Sidebar menu={menu} notifications={notifications} stories={stories} storyId={storyId} />\n",
");\n",
"simple.storyData = { menu, notifications, stories, storyId };\n",
"\n",
"export const loading = () => <Sidebar menu={menu} notifications={notifications} stories={{}} />;\n",
"loading.storyData = { menu, notifications, stories: {} };"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
"export const loading = () => (\n",
" <Sidebar menu={menu} notifications={notifications} stories={{}} loading />\n",
");\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.stories.js",
"type": "replace",
"edit_start_line_idx": 21
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0046539041213691235,
0.0013894160510972142,
0.00017235810810234398,
0.0009081534226424992,
0.001444317284040153
]
|
{
"id": 6,
"code_window": [
" <Sidebar menu={menu} notifications={notifications} stories={stories} storyId={storyId} />\n",
");\n",
"simple.storyData = { menu, notifications, stories, storyId };\n",
"\n",
"export const loading = () => <Sidebar menu={menu} notifications={notifications} stories={{}} />;\n",
"loading.storyData = { menu, notifications, stories: {} };"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
"export const loading = () => (\n",
" <Sidebar menu={menu} notifications={notifications} stories={{}} loading />\n",
");\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.stories.js",
"type": "replace",
"edit_start_line_idx": 21
} | import React from 'react';
import { shallow } from 'enzyme';
import { render } from 'react-testing-library';
import { ThemeProvider, themes } from '@storybook/theming';
import ShortcutsScreen from './shortcuts';
// A limited set of keys we use in this test file
const shortcutKeys = {
fullScreen: ['F'],
togglePanel: ['S'],
toggleNav: ['A'],
toolbar: ['T'],
search: ['/'],
focusNav: ['1'],
focusIframe: ['2'],
};
const makeActions = () => ({
setShortcut: jest.fn(),
restoreDefaultShortcut: jest.fn().mockImplementation(action => shortcutKeys[action]),
restoreAllDefaultShortcuts: jest.fn().mockReturnValue(shortcutKeys),
onClose: jest.fn(),
});
describe('ShortcutsScreen', () => {
it('renders correctly', () => {
const comp = shallow(
<ThemeProvider theme={themes.light}>
<ShortcutsScreen shortcutKeys={shortcutKeys} {...makeActions()} />
</ThemeProvider>
);
expect(comp).toExist();
});
it('handles a full mount', () => {
const comp = render(
<ThemeProvider theme={themes.light}>
<ShortcutsScreen shortcutKeys={shortcutKeys} {...makeActions()} />
</ThemeProvider>
);
expect(comp).toBeDefined();
comp.unmount();
});
describe('onFocus', () => {
it('calls setstate and clears the input on focus', () => {
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...makeActions()} />);
const instance = comp.instance();
instance.onFocus('toolbar')();
expect(comp.state('shortcutKeys').toolbar.shortcut).toBeNull();
expect(comp.state('activeFeature')).toBe('toolbar');
});
});
describe('onKeyDown', () => {
it('does nothing if a modifier key is pressed', () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ isShift: true, key: 'Shift' });
expect(actions.setShortcut).not.toHaveBeenCalled();
expect(comp.state('shortcutKeys').focusIframe.shortcut).toBeNull();
});
it('changes the shortcut in state if a key is pressed', () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ key: 'P' });
expect(actions.setShortcut).not.toHaveBeenCalled();
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['P']);
expect(comp.state('shortcutKeys').focusIframe.error).toBe(false);
});
it('sets an error and the shortcut in state if a duplicate key is pressed', () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ key: 'F' });
expect(actions.setShortcut).not.toHaveBeenCalled();
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['F']);
expect(comp.state('shortcutKeys').focusIframe.error).toBe(true);
});
});
describe('onBlur', () => {
it('if the input is empty, restores the respective default', async () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
await instance.onBlur();
expect(actions.setShortcut).not.toHaveBeenCalled();
expect(actions.restoreDefaultShortcut).toHaveBeenCalledWith('focusIframe');
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['2']);
expect(comp.state('shortcutKeys').focusIframe.error).toBe(false);
});
it('if the shortcut is errored, restores the respective default', async () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ key: 'F' });
await instance.onBlur();
expect(actions.setShortcut).not.toHaveBeenCalled();
expect(actions.restoreDefaultShortcut).toHaveBeenCalledWith('focusIframe');
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['2']);
expect(comp.state('shortcutKeys').focusIframe.error).toBe(false);
});
it('it saves the shortcut if it is valid', () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ key: 'P' });
instance.onBlur();
expect(actions.setShortcut).toHaveBeenCalledWith('focusIframe', ['P']);
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['P']);
expect(comp.state('shortcutKeys').focusIframe.error).toBe(false);
});
});
describe('restoreDefaults', () => {
it('if the input is empty, restores the respective default', async () => {
const actions = makeActions();
const comp = shallow(<ShortcutsScreen shortcutKeys={shortcutKeys} {...actions} />);
const instance = comp.instance();
instance.onFocus('focusIframe')();
instance.onKeyDown({ key: 'P' });
await comp.find('#restoreDefaultsHotkeys').simulate('click');
expect(comp.state('shortcutKeys').focusIframe.shortcut).toEqual(['2']);
});
});
});
| lib/ui/src/settings/shortcuts.test.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017848935385700315,
0.00017375579045619816,
0.00016765402688179165,
0.0001748423237586394,
0.00000349159563484136
]
|
{
"id": 6,
"code_window": [
" <Sidebar menu={menu} notifications={notifications} stories={stories} storyId={storyId} />\n",
");\n",
"simple.storyData = { menu, notifications, stories, storyId };\n",
"\n",
"export const loading = () => <Sidebar menu={menu} notifications={notifications} stories={{}} />;\n",
"loading.storyData = { menu, notifications, stories: {} };"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
"export const loading = () => (\n",
" <Sidebar menu={menu} notifications={notifications} stories={{}} loading />\n",
");\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.stories.js",
"type": "replace",
"edit_start_line_idx": 21
} | # Number of days of inactivity before an issue becomes stale
daysUntilStale: 21
# Number of days of inactivity before a stale issue is closed
daysUntilClose: 30
# Issues with these labels will never be considered stale
exemptLabels:
- todo
- ready
- 'in progress'
- 'do not merge'
- 'needs review'
- 'high priority'
- 'good first issue'
- dependencies:update
# Label to use when marking an issue as stale
staleLabel: inactive
# Comment to post when marking an issue as stale. Set to `false` to disable
markComment: >
Hi everyone! Seems like there hasn't been much going on in this issue lately.
If there are still questions, comments, or bugs, please feel free to continue
the discussion. Unfortunately, we don't have time to get to every issue. We
are always open to contributions so please send us a pull request if you would
like to help. Inactive issues will be closed after 30 days. Thanks!
# Comment to post when closing a stale issue. Set to `false` to disable
closeComment: >
Hey there, it's me again! I am going close this issue to help our maintainers
focus on the current development roadmap instead. If the issue mentioned is
still a concern, please open a new ticket and mention this old one. Cheers
and thanks for using Storybook!
| .github/stale.yml | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017489051970187575,
0.0001715077378321439,
0.0001689803320914507,
0.0001710800570435822,
0.000002161370048270328
]
|
{
"id": 6,
"code_window": [
" <Sidebar menu={menu} notifications={notifications} stories={stories} storyId={storyId} />\n",
");\n",
"simple.storyData = { menu, notifications, stories, storyId };\n",
"\n",
"export const loading = () => <Sidebar menu={menu} notifications={notifications} stories={{}} />;\n",
"loading.storyData = { menu, notifications, stories: {} };"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
"export const loading = () => (\n",
" <Sidebar menu={menu} notifications={notifications} stories={{}} loading />\n",
");\n"
],
"file_path": "lib/ui/src/components/sidebar/Sidebar.stories.js",
"type": "replace",
"edit_start_line_idx": 21
} | import mergeWith from 'lodash.mergewith';
import isEqual from 'lodash.isequal';
import toId, { sanitize } from '../libs/id';
const merge = (a, b) =>
mergeWith({}, a, b, (objValue, srcValue) => {
if (Array.isArray(srcValue) && Array.isArray(objValue)) {
srcValue.forEach(s => {
const existing = objValue.find(o => o === s || isEqual(o, s));
if (!existing) {
objValue.push(s);
}
});
return objValue;
}
if (Array.isArray(objValue)) {
// eslint-disable-next-line no-console
console.log('the types mismatch, picking', objValue);
return objValue;
}
return undefined;
});
const initStoriesApi = ({
store,
navigate,
storyId: initialStoryId,
viewMode: initialViewMode,
}) => {
const getData = storyId => {
const { storiesHash } = store.getState();
return storiesHash[storyId];
};
const getCurrentStoryData = () => {
const { storyId } = store.getState();
return getData(storyId);
};
const getParameters = (storyId, addon) => {
const data = getData(storyId);
if (!data) {
return null;
}
const { parameters } = data;
return addon ? parameters[addon] : parameters;
};
const jumpToStory = direction => {
const { storiesHash, viewMode, storyId } = store.getState();
// cannot navigate when there's no current selection
if (!storyId || !storiesHash[storyId]) {
return;
}
const lookupList = Object.keys(storiesHash).filter(
k => !(storiesHash[k].children || Array.isArray(storiesHash[k]))
);
const index = lookupList.indexOf(storyId);
// cannot navigate beyond fist or last
if (index === lookupList.length - 1 && direction > 0) {
return;
}
if (index === 0 && direction < 0) {
return;
}
if (direction === 0) {
return;
}
const result = lookupList[index + direction];
if (viewMode && result) {
navigate(`/${viewMode}/${result}`);
}
};
const jumpToComponent = direction => {
const state = store.getState();
const { storiesHash, viewMode, storyId } = state;
// cannot navigate when there's no current selection
if (!storyId || !storiesHash[storyId]) {
return;
}
const lookupList = Object.entries(storiesHash).reduce((acc, i) => {
const value = i[1];
if (value.isComponent) {
acc.push([...i[1].children]);
}
return acc;
}, []);
const index = lookupList.findIndex(i => i.includes(storyId));
// cannot navigate beyond fist or last
if (index === lookupList.length - 1 && direction > 0) {
return;
}
if (index === 0 && direction < 0) {
return;
}
if (direction === 0) {
return;
}
const result = lookupList[index + direction][0];
navigate(`/${viewMode || 'story'}/${result}`);
};
const splitPath = (kind, { rootSeparator, groupSeparator }) => {
const [root, remainder] = kind.split(rootSeparator, 2);
const groups = (remainder || kind).split(groupSeparator).filter(i => !!i);
// when there's no remainder, it means the root wasn't found/split
return {
root: remainder ? root : null,
groups,
};
};
const toKey = input =>
input.replace(/[^a-z0-9]+([a-z0-9])/gi, (...params) => params[1].toUpperCase());
const toGroup = name => ({
name,
children: [],
id: toKey(name),
});
const setStories = input => {
const storiesHash = Object.values(input).reduce((acc, item) => {
const { kind, parameters } = item;
const {
hierarchyRootSeparator: rootSeparator,
hierarchySeparator: groupSeparator,
} = parameters.options;
const { root, groups } = splitPath(kind, { rootSeparator, groupSeparator });
const rootAndGroups = []
.concat(root || [])
.concat(groups)
.map(toGroup)
// Map a bunch of extra fields onto the groups, collecting the path as we go (thus the reduce)
.reduce((soFar, group, index, original) => {
const { name } = group;
const parent = index > 0 && soFar[index - 1].id;
const id = sanitize(parent ? `${parent}-${name}` : name);
return soFar.concat([
{
...group,
id,
parent,
depth: index,
isComponent: index === original.length - 1,
isRoot: !!root && index === 0,
},
]);
}, []);
const paths = [...rootAndGroups.map(g => g.id), item.id];
// Ok, now let's add everything to the store
rootAndGroups.forEach((group, index) => {
const child = paths[index + 1];
const { id } = group;
acc[id] = merge(acc[id] || {}, {
...group,
...(child && { children: [child] }),
});
});
acc[item.id] = { ...item, parent: rootAndGroups[rootAndGroups.length - 1].id };
return acc;
}, {});
const { storyId, viewMode } = store.getState();
if (!storyId || !storiesHash[storyId]) {
// when there's no storyId or the storyId item doesn't exist
// we pick the first leaf and navigate
const firstLeaf = Object.values(storiesHash).find(s => !s.children);
if (viewMode && firstLeaf) {
navigate(`/${viewMode}/${firstLeaf.id}`);
}
}
store.setState({ storiesHash });
};
const selectStory = (kindOrId, story) => {
const { viewMode = 'story', storyId } = store.getState();
if (!story) {
navigate(`/${viewMode}/${kindOrId}`);
} else if (!kindOrId) {
// This is a slugified version of the kind, but that's OK, our toId function is idempotent
const kind = storyId.split('--', 2)[0];
selectStory(toId(kind, story));
} else {
selectStory(toId(kindOrId, story));
}
};
return {
api: {
storyId: toId,
selectStory,
getCurrentStoryData,
setStories,
jumpToComponent,
jumpToStory,
getData,
getParameters,
},
state: {
storiesHash: {},
storyId: initialStoryId,
viewMode: initialViewMode,
},
};
};
export default initStoriesApi;
| lib/ui/src/core/stories.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0032470172736793756,
0.000586734851822257,
0.00016593796317465603,
0.00017667250358499587,
0.0008907504379749298
]
|
{
"id": 7,
"code_window": [
"\n",
"const Logo = styled(StorybookLogo)({\n",
" width: 'auto',\n",
" height: 24,\n",
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" height: 22,\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 14
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled } from '@storybook/theming';
import NotificationList, { NotificationListSpacer } from './NotificationList';
import SidebarHeading from './SidebarHeading';
import SidebarStories from './SidebarStories';
const Heading = styled(SidebarHeading)({
padding: '20px 20px 10px',
});
const Container = styled.nav({
position: 'absolute',
zIndex: 1,
left: 0,
top: 0,
bottom: 0,
right: 0,
width: '100%',
height: '100%',
overflowY: 'auto',
overflowX: 'hidden',
});
const Foot = styled.div({});
export const Notifications = styled.div({
position: 'fixed',
display: 'block',
bottom: 0,
margin: 0,
padding: 0,
width: '20%',
minWidth: 200,
maxWidth: 280,
zIndex: 2,
});
const Sidebar = ({ storyId, notifications = [], stories, menu, menuHighlighted }) => (
<Container className="container">
<Heading menuHighlighted={menuHighlighted} menu={menu} />
<SidebarStories stories={stories} storyId={storyId} />
<Foot>
<NotificationListSpacer notifications={notifications} />
</Foot>
<Notifications>
<NotificationList notifications={notifications} />
</Notifications>
</Container>
);
Sidebar.propTypes = {
stories: PropTypes.shape({}).isRequired,
storyId: PropTypes.string,
notifications: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
menuHighlighted: PropTypes.bool,
};
Sidebar.defaultProps = {
storyId: undefined,
menuHighlighted: false,
};
Sidebar.displayName = 'Sidebar';
export default Sidebar;
| lib/ui/src/components/sidebar/Sidebar.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0013263802975416183,
0.0003830734931398183,
0.00016743179003242403,
0.00017348109395243227,
0.0003964513016398996
]
|
{
"id": 7,
"code_window": [
"\n",
"const Logo = styled(StorybookLogo)({\n",
" width: 'auto',\n",
" height: 24,\n",
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" height: 22,\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 14
} |
class {
onCreate() {}
}
style {
#app {
font-family: 'Avenir', Helvetica, Arial, sans-serif;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
text-align: center;
color: #2c3e50;
margin-top: 60px;
}
.logo {
background-image:url('data:image/png;base64,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');
background-repeat:no-repeat;
display:inline-block;
width: 365px;
height: 200px;
}
h1, h2 {
font-weight: normal;
}
ul {
list-style-type: none;
padding: 0;
}
li {
display: inline-block;
margin: 0 10px;
}
a {
color: #42b983;
}
}
<div#app>
<h1>Welcome to Storybook for Marko</h1>
<div.logo></div>
</div>
| lib/cli/generators/MARKO/template/stories/components/welcome/index.marko | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0077803367748856544,
0.0017639223951846361,
0.00016621682152617723,
0.00017478982044849545,
0.0030114175751805305
]
|
{
"id": 7,
"code_window": [
"\n",
"const Logo = styled(StorybookLogo)({\n",
" width: 'auto',\n",
" height: 24,\n",
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" height: 22,\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 14
} | import { buildDev } from '@storybook/core/server';
import options from './options';
buildDev(options);
| app/vue/src/server/index.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00016886740922927856,
0.00016886740922927856,
0.00016886740922927856,
0.00016886740922927856,
0
]
|
{
"id": 7,
"code_window": [
"\n",
"const Logo = styled(StorybookLogo)({\n",
" width: 'auto',\n",
" height: 24,\n",
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" height: 22,\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 14
} | import puppeteer from 'puppeteer';
import { toMatchImageSnapshot } from 'jest-image-snapshot';
import { logger } from '@storybook/node-logger';
import { constructUrl } from './url';
expect.extend({ toMatchImageSnapshot });
// We consider taking the full page is a reasonnable default.
const defaultScreenshotOptions = () => ({ fullPage: true });
const noop = () => {};
const asyncNoop = async () => {};
const defaultConfig = {
storybookUrl: 'http://localhost:6006',
chromeExecutablePath: undefined,
getMatchOptions: noop,
getScreenshotOptions: defaultScreenshotOptions,
beforeScreenshot: noop,
getGotoOptions: noop,
customizePage: asyncNoop,
getCustomBrowser: undefined,
};
export const imageSnapshot = (customConfig = {}) => {
const {
storybookUrl,
chromeExecutablePath,
getMatchOptions,
getScreenshotOptions,
beforeScreenshot,
getGotoOptions,
customizePage,
getCustomBrowser,
} = { ...defaultConfig, ...customConfig };
let browser; // holds ref to browser. (ie. Chrome)
let page; // Hold ref to the page to screenshot.
const testFn = async ({ context }) => {
const { kind, framework, name } = context;
if (framework === 'rn') {
// Skip tests since we de not support RN image snapshots.
logger.error(
"It seems you are running imageSnapshot on RN app and it's not supported. Skipping test."
);
return;
}
const url = constructUrl(storybookUrl, kind, name);
if (!browser || !page) {
logger.error(
`Error when generating image snapshot for test ${kind} - ${name} : It seems the headless browser is not running.`
);
throw new Error('no-headless-browser-running');
}
expect.assertions(1);
let image;
try {
await customizePage(page);
await page.goto(url, getGotoOptions({ context, url }));
await beforeScreenshot(page, { context, url });
image = await page.screenshot(getScreenshotOptions({ context, url }));
} catch (e) {
logger.error(
`Error when connecting to ${url}, did you start or build the storybook first? A storybook instance should be running or a static version should be built when using image snapshot feature.`,
e
);
throw e;
}
expect(image).toMatchImageSnapshot(getMatchOptions({ context, url }));
};
testFn.afterAll = () => {
if (getCustomBrowser && page) {
return page.close();
}
return browser.close();
};
testFn.beforeAll = async () => {
if (getCustomBrowser) {
browser = await getCustomBrowser();
} else {
// add some options "no-sandbox" to make it work properly on some Linux systems as proposed here: https://github.com/Googlechrome/puppeteer/issues/290#issuecomment-322851507
browser = await puppeteer.launch({
args: ['--no-sandbox ', '--disable-setuid-sandbox'],
executablePath: chromeExecutablePath,
});
}
page = await browser.newPage();
};
return testFn;
};
| addons/storyshots/storyshots-puppeteer/src/index.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0011817591730505228,
0.000302929402096197,
0.00017134967492893338,
0.0001766790810506791,
0.0002845540875568986
]
|
{
"id": 8,
"code_window": [
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n",
" display: 'inline-block',\n",
" color: 'inherit',\n",
" textDecoration: 'none',\n",
"});\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" display: 'block',\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 19
} | import React from 'react';
import PropTypes from 'prop-types';
import { styled, withTheme } from '@storybook/theming';
import { StorybookLogo } from '@storybook/components';
import Menu from '../menu/Menu';
const BrandArea = styled.div(({ theme }) => ({
fontSize: `${theme.typography.size.s2}px`,
fontWeight: theme.typography.weight.bold,
}));
const Logo = styled(StorybookLogo)({
width: 'auto',
height: 24,
display: 'block',
});
const LogoLink = styled.a({
display: 'inline-block',
color: 'inherit',
textDecoration: 'none',
});
const Head = styled.div({
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
});
const Brand = withTheme(({ theme: { brand } }) => (
<BrandArea>
{brand || (
<LogoLink href="./">
<Logo />
</LogoLink>
)}
</BrandArea>
));
export default function SidebarHeading({ menuHighlighted, menu, ...props }) {
return (
<Head {...props}>
<Brand />
<Menu highlighted={menuHighlighted} menuItems={menu} />
</Head>
);
}
SidebarHeading.propTypes = {
menuHighlighted: PropTypes.bool,
menu: PropTypes.arrayOf(PropTypes.shape({})).isRequired,
};
SidebarHeading.defaultProps = {
menuHighlighted: false,
};
| lib/ui/src/components/sidebar/SidebarHeading.js | 1 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.9976921081542969,
0.33212894201278687,
0.0001681403664406389,
0.002025080844759941,
0.4681536853313446
]
|
{
"id": 8,
"code_window": [
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n",
" display: 'inline-block',\n",
" color: 'inherit',\n",
" textDecoration: 'none',\n",
"});\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" display: 'block',\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 19
} | import React from 'react';
import addons, { makeDecorator } from '@storybook/addons';
import Events from './constants';
import Container from './container';
export const withBackgrounds = makeDecorator({
name: 'withBackgrounds',
parameterName: 'backgrounds',
skipIfNoParametersOrOptions: true,
allowDeprecatedUsage: true,
wrapper: (getStory, context, { options, parameters }) => {
const data = parameters || options || [];
const backgrounds = Array.isArray(data) ? data : Object.values(data);
let background = 'transparent';
if (backgrounds.length !== 0) {
addons.getChannel().emit(Events.SET, backgrounds);
const defaultOrFirst = backgrounds.find(x => x.default) || backgrounds[0];
if (defaultOrFirst) {
background = defaultOrFirst.value;
}
}
return (
<Container initialBackground={background} channel={addons.getChannel()}>
{getStory(context)}
</Container>
);
},
});
| addons/ondevice-backgrounds/src/index.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017071497859433293,
0.0001687596522970125,
0.00016710914496798068,
0.00016860725008882582,
0.0000013856544001100701
]
|
{
"id": 8,
"code_window": [
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n",
" display: 'inline-block',\n",
" color: 'inherit',\n",
" textDecoration: 'none',\n",
"});\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" display: 'block',\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 19
} | import '@webcomponents/webcomponentsjs/webcomponents-lite';
import '@webcomponents/webcomponentsjs/custom-elements-es5-adapter';
import { window } from 'global';
window.STORYBOOK_ENV = 'polymer';
| app/polymer/src/client/preview/globals.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.00017425217083655298,
0.00017425217083655298,
0.00017425217083655298,
0.00017425217083655298,
0
]
|
{
"id": 8,
"code_window": [
" display: 'block',\n",
"});\n",
"\n",
"const LogoLink = styled.a({\n",
" display: 'inline-block',\n",
" color: 'inherit',\n",
" textDecoration: 'none',\n",
"});\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" display: 'block',\n"
],
"file_path": "lib/ui/src/components/sidebar/SidebarHeading.js",
"type": "replace",
"edit_start_line_idx": 19
} | import packageJson from '../../package.json';
export default {
packageJson,
frameworkPresets: [require.resolve('./framework-preset-preact.js')],
};
| app/preact/src/server/options.js | 0 | https://github.com/storybookjs/storybook/commit/16159d41df2498ff192d89489e1b58e064ea5bcd | [
0.0001758454745868221,
0.0001758454745868221,
0.0001758454745868221,
0.0001758454745868221,
0
]
|
{
"id": 0,
"code_window": [
"import { axiosInstance } from '../../../../../../../core/utils';\n",
"\n",
"const ButtonWithRightMargin = styled(Button)`\n",
" margin-right: ${({ theme }) => theme.spaces[2]}; ;\n",
"`;\n",
"\n",
"export const Regenerate = ({ onRegenerate, idToRegenerate }) => {\n",
" let isLoadingConfirmation = false;\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" margin-right: ${({ theme }) => theme.spaces[2]};\n"
],
"file_path": "packages/core/admin/admin/src/pages/SettingsPage/pages/ApiTokens/EditView/components/Regenerate/index.js",
"type": "replace",
"edit_start_line_idx": 10
} | import React, { useState } from 'react';
import styled from 'styled-components';
import PropTypes from 'prop-types';
import { useIntl } from 'react-intl';
import { Button } from '@strapi/design-system/Button';
import Refresh from '@strapi/icons/Refresh';
import { ConfirmDialog } from '@strapi/helper-plugin';
import { axiosInstance } from '../../../../../../../core/utils';
const ButtonWithRightMargin = styled(Button)`
margin-right: ${({ theme }) => theme.spaces[2]}; ;
`;
export const Regenerate = ({ onRegenerate, idToRegenerate }) => {
let isLoadingConfirmation = false;
const { formatMessage } = useIntl();
const [showConfirmDialog, setShowConfirmDialog] = useState(false);
const handleConfirmRegeneration = async () => {
isLoadingConfirmation = true;
try {
const {
data: {
data: { accessKey },
},
} = await axiosInstance.post(`/admin/api-tokens/${idToRegenerate}/regenerate`);
isLoadingConfirmation = false;
onRegenerate(accessKey);
setShowConfirmDialog(false);
} catch (error) {
isLoadingConfirmation = false;
console.log('error', error);
}
};
return (
<>
<ButtonWithRightMargin
startIcon={<Refresh />}
type="button"
size="S"
variant="tertiary"
onClick={() => setShowConfirmDialog(true)}
>
{formatMessage({
id: 'Settings.apiTokens.regenerate',
defaultMessage: 'Regenerate',
})}
</ButtonWithRightMargin>
<ConfirmDialog
bodyText={{
id: 'Settings.apiTokens.popUpWarning.message',
defaultMessage: 'Are you sure you want to regenerate this token?',
}}
iconRightButton={<Refresh />}
isConfirmButtonLoading={isLoadingConfirmation}
isOpen={showConfirmDialog}
onToggleDialog={() => setShowConfirmDialog(false)}
onConfirm={handleConfirmRegeneration}
leftButtonText={{
id: 'Settings.apiTokens.Button.cancel',
defaultMessage: 'Cancel',
}}
rightButtonText={{
id: 'Settings.apiTokens.Button.regenerate',
defaultMessage: 'Regenerate',
}}
title={{
id: 'Settings.apiTokens.RegenerateDialog.title',
defaultMessage: 'Regenerate token',
}}
/>
</>
);
};
Regenerate.defaultProps = {
onRegenerate() {},
};
Regenerate.propTypes = {
onRegenerate: PropTypes.func,
idToRegenerate: PropTypes.string.isRequired,
};
export default Regenerate;
| packages/core/admin/admin/src/pages/SettingsPage/pages/ApiTokens/EditView/components/Regenerate/index.js | 1 | https://github.com/strapi/strapi/commit/531e9babf2069c78be5c0f98a1e1cbd666686b44 | [
0.998913049697876,
0.8875504732131958,
0.0022302777506411076,
0.9984582662582397,
0.3130086660385132
]
|
{
"id": 0,
"code_window": [
"import { axiosInstance } from '../../../../../../../core/utils';\n",
"\n",
"const ButtonWithRightMargin = styled(Button)`\n",
" margin-right: ${({ theme }) => theme.spaces[2]}; ;\n",
"`;\n",
"\n",
"export const Regenerate = ({ onRegenerate, idToRegenerate }) => {\n",
" let isLoadingConfirmation = false;\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" margin-right: ${({ theme }) => theme.spaces[2]};\n"
],
"file_path": "packages/core/admin/admin/src/pages/SettingsPage/pages/ApiTokens/EditView/components/Regenerate/index.js",
"type": "replace",
"edit_start_line_idx": 10
} | docs/static/.nojekyll | 0 | https://github.com/strapi/strapi/commit/531e9babf2069c78be5c0f98a1e1cbd666686b44 | [
0.00017491252219770104,
0.00017491252219770104,
0.00017491252219770104,
0.00017491252219770104,
0
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.