ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update KCL in JS project

Browse Source
This commit is contained in:
Adam Chalmers
2025-03-17 16:46:08 -05:00
parent f53ef5d370
commit e13ee69c40
34 changed files with 858 additions and 625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
e2e/playwright/feature-tree-pane.spec.ts
View File

@ -19,7 +19,7 @@ length001 = timesFive(1) * 5
sketch001 = startSketchOn(XZ)
|> startProfileAt([20, 10], %)
|> line(end = [10, 10])
|> angledLine([-45, length001], %)
|> angledLine(angle = -45, length = length001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
revolve001 = revolve(sketch001, axis = "X")
@ -38,7 +38,7 @@ extrude001 = extrude(sketch002, length = 10)
const FEATURE_TREE_SKETCH_CODE = `sketch001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> angledLine([0, 4], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 4, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
2

227
e2e/playwright/point-click.spec.ts
View File

@ -105,80 +105,80 @@ test.describe('Point-and-click tests', () => {
toolbar: ToolbarFixture,
scene: SceneFixture
) =>
async ({
clickCoords,
cameraPos,
cameraTarget,
beforeChamferSnippet,
afterChamferSelectSnippet,
afterRectangle1stClickSnippet,
afterRectangle2ndClickSnippet,
beforeChamferSnippetEnd,
}: {
clickCoords: { x: number; y: number }
cameraPos: { x: number; y: number; z: number }
cameraTarget: { x: number; y: number; z: number }
beforeChamferSnippet: string
afterChamferSelectSnippet: string
afterRectangle1stClickSnippet: string
afterRectangle2ndClickSnippet: string
beforeChamferSnippetEnd?: string
}) => {
const [clickChamfer] = scene.makeMouseHelpers(
clickCoords.x,
clickCoords.y
)
const [rectangle1stClick] = scene.makeMouseHelpers(573, 149)
const [rectangle2ndClick, rectangle2ndMove] = scene.makeMouseHelpers(
598,
380,
{ steps: 5 }
)
async ({
clickCoords,
cameraPos,
cameraTarget,
beforeChamferSnippet,
afterChamferSelectSnippet,
afterRectangle1stClickSnippet,
afterRectangle2ndClickSnippet,
beforeChamferSnippetEnd,
}: {
clickCoords: { x: number; y: number }
cameraPos: { x: number; y: number; z: number }
cameraTarget: { x: number; y: number; z: number }
beforeChamferSnippet: string
afterChamferSelectSnippet: string
afterRectangle1stClickSnippet: string
afterRectangle2ndClickSnippet: string
beforeChamferSnippetEnd?: string
}) => {
const [clickChamfer] = scene.makeMouseHelpers(
clickCoords.x,
clickCoords.y
)
const [rectangle1stClick] = scene.makeMouseHelpers(573, 149)
const [rectangle2ndClick, rectangle2ndMove] = scene.makeMouseHelpers(
598,
380,
{ steps: 5 }
)
await scene.moveCameraTo(cameraPos, cameraTarget)
await scene.moveCameraTo(cameraPos, cameraTarget)
await test.step('check chamfer selection changes cursor position', async () => {
await expect(async () => {
// sometimes initial click doesn't register
await test.step('check chamfer selection changes cursor position', async () => {
await expect(async () => {
// sometimes initial click doesn't register
await clickChamfer()
// await editor.expectActiveLinesToBe([beforeChamferSnippet.slice(-5)])
await editor.expectActiveLinesToBe([
beforeChamferSnippetEnd || beforeChamferSnippet.slice(-5),
])
}).toPass({ timeout: 15_000, intervals: [500] })
})
await test.step('starting a new and selecting a chamfer should animate to the new sketch and possible break up the initial chamfer if it had one than more tag', async () => {
await toolbar.startSketchPlaneSelection()
await clickChamfer()
// await editor.expectActiveLinesToBe([beforeChamferSnippet.slice(-5)])
await editor.expectActiveLinesToBe([
beforeChamferSnippetEnd || beforeChamferSnippet.slice(-5),
])
}).toPass({ timeout: 15_000, intervals: [500] })
})
// timeout wait for engine animation is unavoidable
await page.waitForTimeout(1000)
await editor.expectEditor.toContain(afterChamferSelectSnippet)
})
await test.step('make sure a basic sketch can be added', async () => {
await toolbar.rectangleBtn.click()
await rectangle1stClick()
await editor.expectEditor.toContain(afterRectangle1stClickSnippet)
await rectangle2ndMove({
pixelDiff: 50,
})
await rectangle2ndClick()
await editor.expectEditor.toContain(afterRectangle2ndClickSnippet, {
shouldNormalise: true,
})
})
await test.step('starting a new and selecting a chamfer should animate to the new sketch and possible break up the initial chamfer if it had one than more tag', async () => {
await toolbar.startSketchPlaneSelection()
await clickChamfer()
// timeout wait for engine animation is unavoidable
await page.waitForTimeout(1000)
await editor.expectEditor.toContain(afterChamferSelectSnippet)
})
await test.step('make sure a basic sketch can be added', async () => {
await toolbar.rectangleBtn.click()
await rectangle1stClick()
await editor.expectEditor.toContain(afterRectangle1stClickSnippet)
await rectangle2ndMove({
pixelDiff: 50,
await test.step('Clean up so that `_sketchOnAChamfer` util can be called again', async () => {
await toolbar.exitSketch()
})
await rectangle2ndClick()
await editor.expectEditor.toContain(afterRectangle2ndClickSnippet, {
shouldNormalise: true,
await test.step('Check there is no errors after code created in previous steps executes', async () => {
await editor.expectState({
activeLines: ['@settings(defaultLengthUnit = in)'],
highlightedCode: '',
diagnostics: [],
})
})
})
await test.step('Clean up so that `_sketchOnAChamfer` util can be called again', async () => {
await toolbar.exitSketch()
})
await test.step('Check there is no errors after code created in previous steps executes', async () => {
await editor.expectState({
activeLines: ['@settings(defaultLengthUnit = in)'],
highlightedCode: '',
diagnostics: [],
})
})
}
}
test('works on all edge selections and can break up multi edges in a chamfer array', async ({
context,
page,
@ -261,7 +261,7 @@ test.describe('Point-and-click tests', () => {
clickCoords: { x: 677, y: 87 },
cameraPos: { x: -6200, y: 1500, z: 6200 },
cameraTarget: { x: 8300, y: 1100, z: 4800 },
beforeChamferSnippet: `angledLine([0, 268.43], %, $rectangleSegmentA001)chamfer(
beforeChamferSnippet: `angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)chamfer(
length = 30,
tags = [
getNextAdjacentEdge(yo),
@ -302,7 +302,7 @@ test.describe('Point-and-click tests', () => {
`@settings(defaultLengthUnit = in)
sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -320,14 +320,14 @@ extrude001 = extrude(sketch001, length = 100)
|> chamfer(length = 30, tags = [getNextAdjacentEdge(yo)], tag = $seg06)
sketch005 = startSketchOn(extrude001, seg06)
profile004=startProfileAt([-23.43,19.69], sketch005)
|> angledLine([0, 9.1], %, $rectangleSegmentA005)
|> angledLine([segAng(rectangleSegmentA005) - 90, 84.07], %)
|> angledLine([segAng(rectangleSegmentA005), -segLen(rectangleSegmentA005)], %)
|> angledLine(angle = 0, length = 9.1, tag = $rectangleSegmentA005)
|> angledLine(angle = segAng(rectangleSegmentA005) - 90, length = 84.07)
|> angledLine(angle = segAng(rectangleSegmentA005), length = -segLen(rectangleSegmentA005))
|> line(endAbsolute=[profileStartX(%), profileStartY(%)])
|> close()
sketch004 = startSketchOn(extrude001, seg05)
profile003 = startProfileAt([82.57, 322.96], sketch004)
|> angledLine([0, 11.16], %, $rectangleSegmentA004)
|> angledLine(angle = 0, length = 11.16, tag = $rectangleSegmentA004)
|> angledLine([
segAng(rectangleSegmentA004) - 90,
103.07
@ -340,7 +340,7 @@ profile003 = startProfileAt([82.57, 322.96], sketch004)
|> close()
sketch003 = startSketchOn(extrude001, seg04)
profile002 = startProfileAt([-209.64, 255.28], sketch003)
|> angledLine([0, 11.56], %, $rectangleSegmentA003)
|> angledLine(angle = 0, length = 11.56, tag = $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
106.84
@ -353,7 +353,7 @@ profile002 = startProfileAt([-209.64, 255.28], sketch003)
|> close()
sketch002 = startSketchOn(extrude001, seg03)
profile001 = startProfileAt([205.96, 254.59], sketch002)
|> angledLine([0, 11.39], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 11.39, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
105.26
@ -422,7 +422,7 @@ profile001 = startProfileAt([205.96, 254.59], sketch002)
`@settings(defaultLengthUnit = in)
sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %)
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -450,7 +450,7 @@ chamf = chamfer(
)
sketch002 = startSketchOn(extrude001, seg03)
profile001 = startProfileAt([205.96, 254.59], sketch002)
|> angledLine([0, 11.39], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 11.39, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
105.26
@ -3433,8 +3433,8 @@ sweep001 = sweep(sketch001, path = sketch002)
const initialCode = `
sketch001 = startSketchOn(XZ)
|> startProfileAt([-100.0, 100.0], %)
|> angledLine([0, 200.0], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) - 90, 200], %, $rectangleSegmentB001)
|> angledLine(angle = 0, length = 200.0, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) - 90, length = 200, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
@ -3444,7 +3444,7 @@ segAng(rectangleSegmentA001),
extrude001 = extrude(sketch001, length = 200)
sketch002 = startSketchOn(extrude001, rectangleSegmentA001)
|> startProfileAt([-66.77, 84.81], %)
|> angledLine([180, 27.08], %, $rectangleSegmentA002)
|> angledLine(angle = 180, length = 27.08, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
27.8
@ -3519,19 +3519,20 @@ segAng(rectangleSegmentA002),
toolbar,
cmdBar,
}) => {
const initialCode = `sketch001 = startSketchOn(XZ)
|> startProfileAt([-102.57, 101.72], %)
|> angledLine([0, 202.6], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
202.6
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const initialCode = `
sketch001 = startSketchOn(XZ)
|> startProfileAt([-102.57, 101.72], %)
|> angledLine(angle = 0, length = 202.6, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
202.6
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
extrude001 = extrude(sketch001, length = 50)
sketch002 = startSketchOn(extrude001, rectangleSegmentA001)
|> circle(center = [-11.34, 10.0], radius = 8.69)
@ -3549,7 +3550,7 @@ sketch002 = startSketchOn(extrude001, rectangleSegmentA001)
await page.getByText(codeToSelecton).click()
await toolbar.revolveButton.click()
await page.getByText('Edge', { exact: true }).click()
const lineCodeToSelection = `|> angledLine([0, 202.6], %, $rectangleSegmentA001)`
const lineCodeToSelection = `|> angledLine(angle = 0, length = 202.6, tag = $rectangleSegmentA001)`
await page.getByText(lineCodeToSelection).click()
await cmdBar.progressCmdBar()
await cmdBar.progressCmdBar()
@ -3605,22 +3606,26 @@ sketch002 = startSketchOn(extrude001, rectangleSegmentA001)
toolbar,
cmdBar,
}) => {
const initialCode = `sketch002 = startSketchOn(XY)
|> startProfileAt([-2.02, 1.79], %)
|> xLine(length = 2.6)
sketch001 = startSketchOn(-XY)
|> startProfileAt([-0.48, 1.25], %)
|> angledLine([0, 2.38], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) - 90, 2.4], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
extrude001 = extrude(sketch001, length = 5)
sketch003 = startSketchOn(extrude001, 'START')
|> circle(center = [-0.69, 0.56], radius = 0.28)
const initialCode = `
sketch002 = startSketchOn(XY)
|> startProfileAt([-2.02, 1.79], %)
|> xLine(length = 2.6)
sketch001 = startSketchOn('-XY')
|> startProfileAt([-0.48, 1.25], %)
|> angledLine(angle = 0, length = 2.38, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) - 90, length = 2.4, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
extrude001 = extrude(sketch001, length = 5)
sketch003 = startSketchOn(extrude001, 'START')
|> circle(
center = [-0.69, 0.56],
radius = 0.28
)
`
await context.addInitScript((initialCode) => {

2
e2e/playwright/prompt-to-edit-snapshot-tests.spec.ts
View File

@ -41,7 +41,7 @@ sketch002 = startSketchOn(XZ)
extrude002 = extrude(sketch002, length = 50)
sketch003 = startSketchOn(XY)
|> startProfileAt([52.92, 157.81], %)
|> angledLine([0, 176.4], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 176.4, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
53.4

2
e2e/playwright/prompt-to-edit.spec.ts
View File

@ -22,7 +22,7 @@ sketch002 = startSketchOn(XZ)
extrude002 = extrude(sketch002, length = 50)
sketch003 = startSketchOn(XY)
|> startProfileAt([52.92, 157.81], %)
|> angledLine([0, 176.4], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 176.4, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
53.4

6
e2e/playwright/regression-tests.spec.ts
View File

@ -68,7 +68,7 @@ test.describe('Regression tests', { tag: ['@skipWin'] }, () => {
'persistCode',
`sketch001 = startSketchOn(XY)
|> startProfileAt([82.33, 238.21], %)
|> angledLine([0, 288.63], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 288.63, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
197.97
@ -257,7 +257,7 @@ extrude001 = extrude(sketch001, length = 50)
'persistCode',
`exampleSketch = startSketchOn("XZ")
|> startProfileAt([0, 0], %)
|> angledLine({ angle: 50, length: 45 }, %)
|> angledLine(angle = 50, length = 45 )
|> yLine(endAbsolute = 0)
|> close()
|>
@ -313,7 +313,7 @@ extrude001 = extrude(sketch001, length = 50)
await expect(page.locator('.cm-content'))
.toContainText(`exampleSketch = startSketchOn("XZ")
|> startProfileAt([0, 0], %)
|> angledLine({ angle: 50, length: 45 }, %)
|> angledLine(angle = 50, length = 45 )
|> yLine(endAbsolute = 0)
|> close()

30
e2e/playwright/sketch-tests.spec.ts
View File

@ -1960,8 +1960,8 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
)
await crnRect1point2()
await editor.expectEditor.toContain(
`|> angledLine([0, 2.37], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) - 90, 7.8], %)
`|> angledLine(angle = 0, length = 2.37, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) - 90, length = 7.8)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
@ -1978,7 +1978,7 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
await crnRect2point2()
await page.waitForTimeout(300)
await editor.expectEditor.toContain(
`|> angledLine([0, 5.49], %, $rectangleSegmentA002)
`|> angledLine(angle = 0, length = 5.49, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
4.14
@ -2003,7 +2003,7 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
await cntrRect1point2()
await page.waitForTimeout(300)
await editor.expectEditor.toContain(
`|> angledLine([0, 7.06], %, $rectangleSegmentA003)
`|> angledLine(angle = 0, length = 7.06, tag = $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) + 90,
4.34
@ -2025,7 +2025,7 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
await cntrRect2point2()
await page.waitForTimeout(300)
await editor.expectEditor.toContain(
`|> angledLine([0, 3.12], %, $rectangleSegmentA004)
`|> angledLine(angle = 0, length = 3.12, tag = $rectangleSegmentA004)
|> angledLine([
segAng(rectangleSegmentA004) + 90,
6.24
@ -2187,7 +2187,7 @@ profile001 = startProfileAt([6.24, 4.54], sketch001)
|> line(end = [8.61, 0.74])
|> line(end = [10.99, -5.22])
profile002 = startProfileAt([11.19, 5.02], sketch001)
|> angledLine([0, 10.78], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 10.78, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
4.14
@ -2264,7 +2264,7 @@ profile004 = circleThreePoint(sketch001, p1 = [13.44, -6.8], p2 = [13.39, -2.07]
await rectDragTo()
await page.mouse.up()
await editor.expectEditor.toContain(
`angledLine([-7, 10.27], %, $rectangleSegmentA001)`
`angledLine(angle = -7, length = 10.27, tag = $rectangleSegmentA001)`
)
})
@ -2304,7 +2304,7 @@ profile004 = circleThreePoint(sketch001, p1 = [13.44, -6.8], p2 = [13.39, -2.07]
await page.waitForTimeout(100)
await rectEnd()
await editor.expectEditor.toContain(
`|> angledLine([180, 1.97], %, $rectangleSegmentA002)
`|> angledLine(angle = 180, length = 1.97, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) + 90,
3.89
@ -2333,7 +2333,7 @@ profile001 = startProfileAt([6.24, 4.54], sketch001)
|> line(end = [8.61, 0.74])
|> line(end = [10.99, -5.22])
profile002 = startProfileAt([11.19, 5.02], sketch001)
|> angledLine([0, 10.78], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 10.78, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
4.14
@ -2375,7 +2375,7 @@ profile003 = circle(sketch001, center = [6.92, -4.2], radius = 3.16)
await page.waitForTimeout(600)
})
await test.step('select and delete code for a profile', async () => {})
await test.step('select and delete code for a profile', async () => { })
await page.getByText('close()').click()
await page.keyboard.down('Shift')
for (let i = 0; i < 11; i++) {
@ -2442,7 +2442,7 @@ profile001 = startProfileAt([-63.43, 193.08], sketch001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
profile003 = startProfileAt([16.79, 38.24], sketch001)
|> angledLine([0, 182.82], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 182.82, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
105.71
@ -2666,7 +2666,7 @@ profile002 = startProfileAt([0.75, 13.46], sketch002)
|> line(end = [4.52, 3.79])
|> line(end = [5.98, -2.81])
profile003 = startProfileAt([3.19, 13.3], sketch002)
|> angledLine([0, 6.64], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 6.64, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
2.81
@ -2714,7 +2714,7 @@ profile010 = circle(
radius = 2.67
)
profile011 = startProfileAt([5.07, -6.39], sketch003)
|> angledLine([0, 4.54], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 4.54, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
4.17
@ -2871,7 +2871,7 @@ loft([profile001, profile002])
)
await rect1Crn2()
await editor.expectEditor.toContain(
`angledLine([0, 113.01], %, $rectangleSegmentA001)`
`angledLine(angle = 0, length = 113.01, tag = $rectangleSegmentA001)`
)
}
)
@ -2942,7 +2942,7 @@ loft([profile001, profile002])
)
await rect1Crn2()
await editor.expectEditor.toContain(
`angledLine([0, 106.42], %, $rectangleSegmentA001)`
`angledLine(angle = 0, length = 106.42], tag = $rectangleSegmentA001)`
)
await page.waitForTimeout(100)
})

6
e2e/playwright/snapshot-tests.spec.ts
View File

@ -56,7 +56,7 @@ test(
// And you will need to have the KittyCAD CLI installed
const u = await getUtils(page)
await context.addInitScript(async () => {
;(window as any).playwrightSkipFilePicker = true
; (window as any).playwrightSkipFilePicker = true
localStorage.setItem(
'persistCode',
`topAng = 25
@ -81,7 +81,7 @@ part001 = startSketchOn(-XZ)
offset = -armThick,
intersectTag = seg04
}, %)
|> angledLineToY([segAng(seg04, %) + 180, turns::ZERO], %)
|> angledLine(angle = segAng(seg04, %) + 180, endAbsoluteY = turns::ZERO)
|> angledLineToY({
angle = -bottomAng,
to = -totalHeightHalf - armThick,
@ -93,7 +93,7 @@ part001 = startSketchOn(-XZ)
offset = -armThick,
intersectTag = seg02
}, %)
|> angledLineToY([segAng(seg02, %) + 180, -baseHeight], %)
|> angledLine(angle = segAng(seg02, %) + 180, endAbsoluteY = -baseHeight)
|> xLine(endAbsolute = turns::ZERO)
|> close()
|> extrude(length = 4)`

6
e2e/playwright/snapshots/prompt-to-edit/prompt-to-edit-snapshot-tests-spec-ts--change-colour.snap.json
View File

@ -1,5 +1,11 @@
{
<<<<<<< HEAD
"original_source_code": "sketch001 = startSketchOn('XZ')\nprofile001 = startProfileAt([57.81, 250.51], sketch001)\n |> line(end = [121.13, 56.63], tag = $seg02)\n |> line(end = [83.37, -34.61], tag = $seg01)\n |> line(end = [19.66, -116.4])\n |> line(end = [-221.8, -41.69])\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude001 = extrude(profile001, length = 200)\nsketch002 = startSketchOn('XZ')\n |> startProfileAt([-73.64, -42.89], %)\n |> xLine(length = 173.71)\n |> line(end = [-22.12, -94.4])\n |> xLine(length = -156.98)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude002 = extrude(sketch002, length = 50)\nsketch003 = startSketchOn(XY)\n |> startProfileAt([52.92, 157.81], %)\n |> angledLine([0, 176.4], %, $rectangleSegmentA001)\n |> angledLine([\n segAng(rectangleSegmentA001) - 90,\n 53.4\n ], %, $rectangleSegmentB001)\n |> angledLine([\n segAng(rectangleSegmentA001),\n -segLen(rectangleSegmentA001)\n ], %, $rectangleSegmentC001)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude003 = extrude(sketch003, length = 20)\n",
||||||| parent of bcbec9f87 (Update KCL in JS project)
"original_source_code": "sketch001 = startSketchOn('XZ')\nprofile001 = startProfileAt([57.81, 250.51], sketch001)\n |> line(end = [121.13, 56.63], tag = $seg02)\n |> line(end = [83.37, -34.61], tag = $seg01)\n |> line(end = [19.66, -116.4])\n |> line(end = [-221.8, -41.69])\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude001 = extrude(profile001, length = 200)\nsketch002 = startSketchOn('XZ')\n |> startProfileAt([-73.64, -42.89], %)\n |> xLine(length = 173.71)\n |> line(end = [-22.12, -94.4])\n |> xLine(length = -156.98)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude002 = extrude(sketch002, length = 50)\nsketch003 = startSketchOn('XY')\n |> startProfileAt([52.92, 157.81], %)\n |> angledLine([0, 176.4], %, $rectangleSegmentA001)\n |> angledLine([\n segAng(rectangleSegmentA001) - 90,\n 53.4\n ], %, $rectangleSegmentB001)\n |> angledLine([\n segAng(rectangleSegmentA001),\n -segLen(rectangleSegmentA001)\n ], %, $rectangleSegmentC001)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude003 = extrude(sketch003, length = 20)\n",
=======
"original_source_code": "sketch001 = startSketchOn('XZ')\nprofile001 = startProfileAt([57.81, 250.51], sketch001)\n |> line(end = [121.13, 56.63], tag = $seg02)\n |> line(end = [83.37, -34.61], tag = $seg01)\n |> line(end = [19.66, -116.4])\n |> line(end = [-221.8, -41.69])\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude001 = extrude(profile001, length = 200)\nsketch002 = startSketchOn('XZ')\n |> startProfileAt([-73.64, -42.89], %)\n |> xLine(length = 173.71)\n |> line(end = [-22.12, -94.4])\n |> xLine(length = -156.98)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude002 = extrude(sketch002, length = 50)\nsketch003 = startSketchOn('XY')\n |> startProfileAt([52.92, 157.81], %)\n |> angledLine(angle = 0, 176.4], %, $rectangleSegmentA001)\n |> angledLine([\n segAng(rectangleSegmentA001) - 90,\n 53.4\n ], %, length = $rectangleSegmentB001)\n |> angledLine([\n segAng(rectangleSegmentA001),\n -segLen(rectangleSegmentA001)\n , tag = $rectangleSegmentC001)\n |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n |> close()\nextrude003 = extrude(sketch003, length = 20)\n",
>>>>>>> bcbec9f87 (Update KCL in JS project)
"prompt": "make this neon green please, use #39FF14",
"source_ranges": [
{

10
e2e/playwright/storageStates.ts
View File

@ -83,15 +83,15 @@ export const TEST_SETTINGS_CORRUPTED = {
export const TEST_CODE_GIZMO = `part001 = startSketchOn(XZ)
|> startProfileAt([20, 0], %)
|> line(end = [7.13, 4 + 0])
|> angledLine({ angle: 3 + 0, length: 3.14 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 3.14 + 0 )
|> line(endAbsolute = [20.14 + 0, -0.14 + 0])
|> xLine(endAbsolute = 29 + 0)
|> yLine(length = -3.14 + 0, tag = $a)
|> xLine(length = 1.63)
|> angledLineOfXLength({ angle: 3 + 0, length: 3.14 }, %)
|> angledLineOfYLength({ angle: 30, length: 3 + 0 }, %)
|> angledLineToX({ angle: 22.14 + 0, to: 12 }, %)
|> angledLineToY({ angle: 30, to: 11.14 }, %)
|> angledLine(angle = 3 + 0, lengthX = 3.14 )
|> angledLine(angle = 30, lengthY = 3 + 0 )
|> angledLine(angle = 22.14 + 0, endAbsoluteX = 12)
|> angledLine(angle = 30, endAbsoluteY = 11.14)
|> angledLineThatIntersects({
angle: 3.14,
intersectTag: a,

18
e2e/playwright/testing-constraints.spec.ts
View File

@ -58,7 +58,13 @@ test.describe('Testing constraints', { tag: ['@skipWin'] }, () => {
.click()
await expect(page.locator('.cm-content')).toHaveText(
<<<<<<< HEAD
`length001 = 20sketch001 = startSketchOn(XY) |> startProfileAt([-10, -10], %) |> line(end = [20, 0]) |> angledLine([90, length001], %) |> xLine(length = -20)`
||||||| parent of bcbec9f87 (Update KCL in JS project)
`length001 = 20sketch001 = startSketchOn('XY') |> startProfileAt([-10, -10], %) |> line(end = [20, 0]) |> angledLine([90, length001], %) |> xLine(length = -20)`
=======
`length001 = 20sketch001 = startSketchOn('XY') |> startProfileAt([-10, -10], %) |> line(end = [20, 0]) |> angledLine(angle = 90, length = length001) |> xLine(length = -20)`
>>>>>>> bcbec9f87 (Update KCL in JS project)
)
// Make sure we didn't pop out of sketch mode.
@ -87,7 +93,7 @@ test.describe('Testing constraints', { tag: ['@skipWin'] }, () => {
|> startProfileAt([-7.54, -26.74], %)
|> line(end = [74.36, 130.4], tag = $seg01)
|> line(end = [78.92, -120.11])
|> angledLine([segAng(seg01), yo], %)
|> angledLine(angle = segAng(seg01), length = yo)
|> line(end = [41.19, 58.97 + 5])
part002 = startSketchOn(XZ)
|> startProfileAt([299.05, 120], %)
@ -152,7 +158,7 @@ test.describe('Testing constraints', { tag: ['@skipWin'] }, () => {
|> startProfileAt([-7.54, -26.74], %)
|> line(end = [74.36, 130.4], tag = $seg01)
|> line(end = [78.92, -120.11])
|> angledLine([segAng(seg01), 78.33], %)
|> angledLine(angle = segAng(seg01), length = 78.33)
|> line(end = [51.19, 48.97])
part002 = startSketchOn(XZ)
|> startProfileAt([299.05, 231.45], %)
@ -542,7 +548,7 @@ test.describe('Testing constraints', { tag: ['@skipWin'] }, () => {
// checking activeLines assures the cursors are where they should be
const codeAfter = [
'|> line(end = [74.36, 130.4], tag = $seg01)',
`|> angledLine([${value}, 78.33], %)`,
`|> angledLine(angle = ${value}, length = 78.33)`,
]
if (axisSelect) codeAfter.shift()
@ -831,11 +837,11 @@ part002 = startSketchOn(XZ)
test.describe('Two segment - no modal constraints', () => {
const cases = [
{
codeAfter: `|> angledLine([83, segLen(seg01)], %)`,
codeAfter: `|> angledLine(angle = 83, length = segLen(seg01))`,
constraintName: 'Equal Length',
},
{
codeAfter: `|> angledLine([segAng(seg01), 78.33], %)`,
codeAfter: `|> angledLine(angle = segAng(seg01), length = 78.33)`,
constraintName: 'Parallel',
},
{
@ -1150,7 +1156,7 @@ test.describe('Electron constraint tests', () => {
await clickOnFirstSegmentLabel()
await cmdBar.progressCmdBar()
await editor.expectEditor.toContain('length001 = 15.3')
await editor.expectEditor.toContain('|> angledLine([9, length001], %)')
await editor.expectEditor.toContain('|> angledLine(angle = 9, length = length001)')
})
await test.step('Double click again and expect failure', async () => {

2
e2e/playwright/testing-gizmo.spec.ts
View File

@ -259,7 +259,7 @@ test.describe(`Testing gizmo, fixture-based`, () => {
`@settings(defaultLengthUnit = in)
const sketch002 = startSketchOn(XZ)
|> startProfileAt([-108.83, -57.48], %)
|> angledLine([0, 105.13], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 105.13, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
77.9

702
e2e/playwright/testing-segment-overlays.spec.ts
View File

@ -26,90 +26,90 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
*/
const _clickConstrained =
(page: Page, editor: EditorFixture) =>
async ({
hoverPos,
constraintType,
expectBeforeUnconstrained,
expectAfterUnconstrained,
expectFinal,
ang = 45,
steps = 10,
locator,
}: {
hoverPos: { x: number; y: number }
constraintType:
async ({
hoverPos,
constraintType,
expectBeforeUnconstrained,
expectAfterUnconstrained,
expectFinal,
ang = 45,
steps = 10,
locator,
}: {
hoverPos: { x: number; y: number }
constraintType:
| 'horizontal'
| 'vertical'
| 'tangentialWithPrevious'
| LineInputsType
expectBeforeUnconstrained: string
expectAfterUnconstrained: string
expectFinal: string
ang?: number
steps?: number
locator?: string
}) => {
await expect(page.getByText('Added variable')).not.toBeVisible()
expectBeforeUnconstrained: string
expectAfterUnconstrained: string
expectFinal: string
ang?: number
steps?: number
locator?: string
}) => {
await expect(page.getByText('Added variable')).not.toBeVisible()
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await editor.expectEditor.toContain(expectBeforeUnconstrained, {
shouldNormalise: true,
})
const constrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="true"]`
)
await expect(constrainedLocator).toBeVisible()
await constrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await constrainedLocator.click()
await editor.expectEditor.toContain(expectAfterUnconstrained, {
shouldNormalise: true,
})
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
const unconstrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="false"]`
)
await expect(unconstrainedLocator).toBeVisible()
await unconstrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await unconstrainedLocator.click()
await expect(
page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
).toBeFocused()
await page
.getByRole('button', {
name: 'arrow right Continue',
await editor.expectEditor.toContain(expectBeforeUnconstrained, {
shouldNormalise: true,
})
.click()
await expect(page.locator('.cm-content')).toContainText(expectFinal)
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
}
const constrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="true"]`
)
await expect(constrainedLocator).toBeVisible()
await constrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await constrainedLocator.click()
await editor.expectEditor.toContain(expectAfterUnconstrained, {
shouldNormalise: true,
})
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
const unconstrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="false"]`
)
await expect(unconstrainedLocator).toBeVisible()
await unconstrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await unconstrainedLocator.click()
await expect(
page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
).toBeFocused()
await page
.getByRole('button', {
name: 'arrow right Continue',
})
.click()
await expect(page.locator('.cm-content')).toContainText(expectFinal)
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
}
/**
* Clicks on an unconstrained element
@ -122,85 +122,85 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
*/
const _clickUnconstrained =
(page: Page, editor: EditorFixture) =>
async ({
hoverPos,
constraintType,
expectBeforeUnconstrained,
expectAfterUnconstrained,
expectFinal,
ang = 45,
steps = 5,
locator,
}: {
hoverPos: { x: number; y: number }
constraintType:
async ({
hoverPos,
constraintType,
expectBeforeUnconstrained,
expectAfterUnconstrained,
expectFinal,
ang = 45,
steps = 5,
locator,
}: {
hoverPos: { x: number; y: number }
constraintType:
| 'horizontal'
| 'vertical'
| 'tangentialWithPrevious'
| LineInputsType
expectBeforeUnconstrained: string
expectAfterUnconstrained: string
expectFinal: string
ang?: number
steps?: number
locator?: string
}) => {
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
expectBeforeUnconstrained: string
expectAfterUnconstrained: string
expectFinal: string
ang?: number
steps?: number
locator?: string
}) => {
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await expect(page.getByText('Added variable')).not.toBeVisible()
await editor.expectEditor.toContain(expectBeforeUnconstrained, {
shouldNormalise: true,
})
const unconstrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="false"]`
)
await unconstrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await unconstrainedLocator.click()
await expect(
page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
).toBeFocused()
await page
.getByRole('button', {
name: 'arrow right Continue',
await expect(page.getByText('Added variable')).not.toBeVisible()
await editor.expectEditor.toContain(expectBeforeUnconstrained, {
shouldNormalise: true,
})
.click()
await editor.expectEditor.toContain(expectAfterUnconstrained, {
shouldNormalise: true,
})
await expect(page.getByText('Added variable')).not.toBeVisible()
const unconstrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="false"]`
)
await unconstrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await unconstrainedLocator.click()
await expect(
page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
).toBeFocused()
await page
.getByRole('button', {
name: 'arrow right Continue',
})
.click()
await editor.expectEditor.toContain(expectAfterUnconstrained, {
shouldNormalise: true,
})
await expect(page.getByText('Added variable')).not.toBeVisible()
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
const constrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="true"]`
)
await expect(constrainedLocator).toBeVisible()
await constrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await constrainedLocator.click()
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
}
const constrainedLocator = page.locator(
`[data-constraint-type="${constraintType}"][data-is-constrained="true"]`
)
await expect(constrainedLocator).toBeVisible()
await constrainedLocator.hover()
await expect(
await page.getByTestId('constraint-symbol-popover').count()
).toBeGreaterThan(0)
await constrainedLocator.click()
await editor.expectEditor.toContain(expectFinal, {
shouldNormalise: true,
})
}
test.setTimeout(120000)
test('for segments [line, angledLine, xLineTo]', async ({
page,
@ -214,16 +214,16 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
part001 = startSketchOn(XZ)
|> startProfileAt([5 + 0, 20 + 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 32 + 0 )
|> line(endAbsolute = [5 + 33, 20 + 11.5 + 0])
|> xLine(endAbsolute = 5 + 9 - 5)
|> yLine(endAbsolute = 20 + -10.77, tag = $a)
|> xLine(length = 26.04)
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLineToX({ angle = 3 + 0, to = 5 + 26 }, %)
|> angledLineToY({ angle = 89, to = 20 + 9.14 + 0 }, %)
|> angledLine(angle = 181 + 0, xLength = 23.14)
|> angledLine(angle = -91, yLength = 19 + 0)
|> angledLine(angle = 3 + 0, endAbsoluteX = 5 + 26)
|> angledLine(angle = 89, endAbsoluteY = 20 + 9.14 + 0)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
@ -307,10 +307,10 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
hoverPos: { x: angledLine.x, y: angledLine.y },
constraintType: 'angle',
expectBeforeUnconstrained:
'angledLine({ angle = 3 + 0, length = 32 + 0 }, %)',
'angledLine(angle = 3 + 0, length = 32 + 0)',
expectAfterUnconstrained:
'angledLine({ angle = 3, length = 32 + 0 }, %)',
expectFinal: 'angledLine({ angle = angle001, length = 32 + 0 }, %)',
'angledLine(angle = 3, length = 32 + 0)',
expectFinal: 'angledLine(angle = angle001, length = 32 + 0)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="1"]',
})
@ -319,10 +319,10 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
hoverPos: { x: angledLine.x, y: angledLine.y },
constraintType: 'length',
expectBeforeUnconstrained:
'angledLine({ angle = angle001, length = 32 + 0 }, %)',
'angledLine(angle = angle001, length = 32 + 0)',
expectAfterUnconstrained:
'angledLine({ angle = angle001, length = 32 }, %)',
expectFinal: 'angledLine({ angle = angle001, length = len001 }, %)',
'angledLine(angle = angle001, length = 32)',
expectFinal: 'angledLine(angle = angle001, length = len001)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="1"]',
})
@ -392,7 +392,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
part001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> line(end = [0.5, yRel001])
|> angledLine({ angle = angle001, length = len001 }, %)
|> angledLine(angle = angle001, length = len001 )
|> line(endAbsolute = [33, yAbs001])
|> xLine(endAbsolute = xAbs002)
|> yLine(endAbsolute = -10.77, tag = $a)
@ -465,7 +465,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
part001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 32 + 0 )
|> line(endAbsolute = [33, 11.5 + 0])
|> xLine(endAbsolute = 9 - 5)
|> yLine(endAbsolute = -10.77, tag = $a)
@ -473,8 +473,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLineToX({ angle = 3 + 0, to = 26 }, %)
|> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
|> angledLine(angle = 3 + 0, endAbsoluteX = 26)
|> angledLine(angle = 89, endAbsoluteY = 9.14 + 0)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
@ -597,7 +597,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
part001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 32 + 0 )
|> line(endAbsolute = [33, 11.5 + 0])
|> xLine(endAbsolute = 9 - 5)
|> yLine(endAbsolute = -10.77, tag = $a)
@ -605,8 +605,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLineToX({ angle = 3 + 0, to = 26 }, %)
|> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
|> angledLine(angle = 3 + 0, endAbsoluteX = 26)
|> angledLine(angle = 89, endAbsoluteY = 9.14 + 0)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
@ -614,11 +614,177 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
}, %)
|> tangentialArcTo([3.14 + 13, 1.14], %)
`
<<<<<<< HEAD
||||||| parent of bcbec9f87 (Update KCL in JS project)
)
localStorage.setItem('disableAxis', 'true')
})
const u = await getUtils(page)
await page.setBodyDimensions({ width: 1200, height: 500 })
await homePage.goToModelingScene()
// wait for execution done
await u.openDebugPanel()
await u.expectCmdLog('[data-message-type="execution-done"]')
await u.closeDebugPanel()
await page.getByText('xLine(endAbsolute = 9 - 5)').click()
await page.waitForTimeout(100)
await page.getByRole('button', { name: 'Edit Sketch' }).click()
await page.waitForTimeout(500)
await expect(page.getByTestId('segment-overlay')).toHaveCount(13)
const clickUnconstrained = _clickUnconstrained(page, editor)
const clickConstrained = _clickConstrained(page, editor)
let ang = 0
const angledLineToX = await u.getBoundingBox(`[data-overlay-index="9"]`)
ang = await u.getAngle(`[data-overlay-index="9"]`)
console.log('angledLineToX')
await clickConstrained({
hoverPos: { x: angledLineToX.x, y: angledLineToX.y },
constraintType: 'angle',
expectBeforeUnconstrained:
'angledLineToX({ angle = 3 + 0, to = 26 }, %)',
expectAfterUnconstrained: 'angledLineToX({ angle = 3, to = 26 }, %)',
expectFinal: 'angledLineToX({ angle = angle001, to = 26 }, %)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="9"]',
})
console.log('angledLineToX2')
await clickUnconstrained({
hoverPos: { x: angledLineToX.x, y: angledLineToX.y },
constraintType: 'xAbsolute',
expectBeforeUnconstrained:
'angledLineToX({ angle = angle001, to = 26 }, %)',
expectAfterUnconstrained:
'angledLineToX({ angle = angle001, to = xAbs001 }, %)',
expectFinal: 'angledLineToX({ angle = angle001, to = 26 }, %)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="9"]',
})
const angledLineToY = await u.getBoundingBox(
`[data-overlay-index="10"]`
=======
)
localStorage.setItem('disableAxis', 'true')
})
const u = await getUtils(page)
await page.setBodyDimensions({ width: 1200, height: 500 })
await homePage.goToModelingScene()
// wait for execution done
await u.openDebugPanel()
await u.expectCmdLog('[data-message-type="execution-done"]')
await u.closeDebugPanel()
await page.getByText('xLine(endAbsolute = 9 - 5)').click()
await page.waitForTimeout(100)
await page.getByRole('button', { name: 'Edit Sketch' }).click()
await page.waitForTimeout(500)
await expect(page.getByTestId('segment-overlay')).toHaveCount(13)
const clickUnconstrained = _clickUnconstrained(page, editor)
const clickConstrained = _clickConstrained(page, editor)
let ang = 0
const angledLineToX = await u.getBoundingBox(`[data-overlay-index="9"]`)
ang = await u.getAngle(`[data-overlay-index="9"]`)
console.log('angledLineToX')
await clickConstrained({
hoverPos: { x: angledLineToX.x, y: angledLineToX.y },
constraintType: 'angle',
expectBeforeUnconstrained:
'angledLine(angle = 3 + 0, endAbsoluteX = 26)',
expectAfterUnconstrained: 'angledLine(angle = 3, endAbsoluteX = 26)',
expectFinal: 'angledLine(angle = angle001, endAbsoluteX = 26)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="9"]',
})
console.log('angledLineToX2')
await clickUnconstrained({
hoverPos: { x: angledLineToX.x, y: angledLineToX.y },
constraintType: 'xAbsolute',
expectBeforeUnconstrained:
'angledLine(angle = angle001, endAbsoluteX = 26)',
expectAfterUnconstrained:
'angledLine(angle = angle001, endAbsoluteX = xAbs001)',
expectFinal: 'angledLine(angle = angle001, endAbsoluteX = 26)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="9"]',
})
const angledLineToY = await u.getBoundingBox(
`[data-overlay-index="10"]`
>>>>>>> bcbec9f87 (Update KCL in JS project)
)
<<<<<<< HEAD
localStorage.setItem('disableAxis', 'true')
})
const u = await getUtils(page)
await page.setBodyDimensions({ width: 1200, height: 500 })
||||||| parent of bcbec9f87 (Update KCL in JS project)
ang = await u.getAngle(`[data-overlay-index="10"]`)
console.log('angledLineToY')
await clickUnconstrained({
hoverPos: { x: angledLineToY.x, y: angledLineToY.y },
constraintType: 'angle',
expectBeforeUnconstrained:
'angledLineToY({ angle = 89, to = 9.14 + 0 }, %)',
expectAfterUnconstrained:
'angledLineToY({ angle = angle002, to = 9.14 + 0 }, %)',
expectFinal: 'angledLineToY({ angle = 89, to = 9.14 + 0 }, %)',
steps: process.platform === 'darwin' ? 8 : 9,
ang: ang + 180,
locator: '[data-overlay-toolbar-index="10"]',
})
console.log('angledLineToY2')
await clickConstrained({
hoverPos: { x: angledLineToY.x, y: angledLineToY.y },
constraintType: 'yAbsolute',
expectBeforeUnconstrained:
'angledLineToY({ angle = 89, to = 9.14 + 0 }, %)',
expectAfterUnconstrained:
'angledLineToY({ angle = 89, to = 9.14 }, %)',
expectFinal: 'angledLineToY({ angle = 89, to = yAbs001 }, %)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="10"]',
})
=======
ang = await u.getAngle(`[data-overlay-index="10"]`)
console.log('angledLineToY')
await clickUnconstrained({
hoverPos: { x: angledLineToY.x, y: angledLineToY.y },
constraintType: 'angle',
expectBeforeUnconstrained:
'angledLine(angle = 89, endAbsoluteY = 9.14 + 0)',
expectAfterUnconstrained:
'angledLine(angle = angle002, endAbsoluteY = 9.14 + 0)',
expectFinal: 'angledLine(angle = 89, endAbsoluteY = 9.14 + 0)',
steps: process.platform === 'darwin' ? 8 : 9,
ang: ang + 180,
locator: '[data-overlay-toolbar-index="10"]',
})
console.log('angledLineToY2')
await clickConstrained({
hoverPos: { x: angledLineToY.x, y: angledLineToY.y },
constraintType: 'yAbsolute',
expectBeforeUnconstrained:
'angledLine(angle = 89, endAbsoluteY = 9.14 + 0)',
expectAfterUnconstrained:
'angledLine(angle = 89, endAbsoluteY = 9.14)',
expectFinal: 'angledLine(angle = 89, endAbsoluteY = yAbs001)',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="10"]',
})
>>>>>>> bcbec9f87 (Update KCL in JS project)
await homePage.goToModelingScene()
@ -759,7 +925,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
part001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 32 + 0 )
|> line(endAbsolute = [33, 11.5 + 0])
|> xLine(endAbsolute = 9 - 5)
|> yLine(endAbsolute = -10.77, tag = $a)
@ -767,8 +933,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLineToX({ angle = 3 + 0, to = 26 }, %)
|> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
|> angledLine(angle = 3 + 0, endAbsoluteX = 26)
|> angledLine(angle = 89, endAbsoluteY = 9.14 + 0)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
@ -1033,47 +1199,47 @@ part001 = startSketchOn(XZ)
test.describe('Testing deleting a segment', () => {
const _deleteSegmentSequence =
(page: Page, editor: EditorFixture) =>
async ({
hoverPos,
codeToBeDeleted,
stdLibFnName,
ang = 45,
steps = 6,
locator,
}: {
hoverPos: { x: number; y: number }
codeToBeDeleted: string
stdLibFnName: string
ang?: number
steps?: number
locator?: string
}) => {
await expect(page.getByText('Added variable')).not.toBeVisible()
async ({
hoverPos,
codeToBeDeleted,
stdLibFnName,
ang = 45,
steps = 6,
locator,
}: {
hoverPos: { x: number; y: number }
codeToBeDeleted: string
stdLibFnName: string
ang?: number
steps?: number
locator?: string
}) => {
await expect(page.getByText('Added variable')).not.toBeVisible()
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await page.mouse.move(0, 0)
await page.waitForTimeout(1000)
let x = 0,
y = 0
x = hoverPos.x + Math.cos(ang * deg) * 32
y = hoverPos.y - Math.sin(ang * deg) * 32
await page.mouse.move(x, y)
await wiggleMove(page, x, y, 20, 30, ang, 10, 5, locator)
await page.mouse.move(x, y)
await editor.expectEditor.toContain(codeToBeDeleted, {
shouldNormalise: true,
})
await editor.expectEditor.toContain(codeToBeDeleted, {
shouldNormalise: true,
})
await page
.locator(`[data-stdlib-fn-name="${stdLibFnName}"]`)
.first()
.click()
await page.getByText('Delete Segment').click()
await page
.locator(`[data-stdlib-fn-name="${stdLibFnName}"]`)
.first()
.click()
await page.getByText('Delete Segment').click()
await editor.expectEditor.not.toContain(codeToBeDeleted, {
shouldNormalise: true,
})
}
await editor.expectEditor.not.toContain(codeToBeDeleted, {
shouldNormalise: true,
})
}
test('all segment types', async ({
page,
editor,
@ -1084,6 +1250,7 @@ part001 = startSketchOn(XZ)
await page.addInitScript(async () => {
localStorage.setItem(
'persistCode',
<<<<<<< HEAD
`@settings(defaultLengthUnit = in)
part001 = startSketchOn(XZ)
|>startProfileAt([0, 0], %)
@ -1114,7 +1281,48 @@ part001 = startSketchOn(XZ)
angleEnd = -38.05
}, %)
`
||||||| parent of bcbec9f87 (Update KCL in JS project)
`part001 = startSketchOn('XZ')
|> startProfileAt([0, 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
|> line(endAbsolute = [33, 11.5 + 0])
|> xLine(endAbsolute = 9 - 5)
|> yLine(endAbsolute = -10.77, tag = $a)
|> xLine(length = 26.04)
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLineToX({ angle = 3 + 0, to = 26 }, %)
|> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
offset = 9
}, %)
|> tangentialArcTo([3.14 + 13, 1.14], %)
=======
`part001 = startSketchOn('XZ')
|> startProfileAt([0, 0], %)
|> line(end = [0.5, -14 + 0])
|> angledLine(angle = 3 + 0, length = 32 + 0 )
|> line(endAbsolute = [33, 11.5 + 0])
|> xLine(endAbsolute = 9 - 5)
|> yLine(endAbsolute = -10.77, tag = $a)
|> xLine(length = 26.04)
|> yLine(length = 21.14 + 0)
|> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
|> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
|> angledLine(angle = 3 + 0, endAbsoluteX = 26)
|> angledLine(angle = 89, endAbsoluteY = 9.14 + 0)
|> angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
offset = 9
}, %)
|> tangentialArcTo([3.14 + 13, 1.14], %)
>>>>>>> bcbec9f87 (Update KCL in JS project)
`
)
localStorage.setItem('disableAxis', 'true')
})
@ -1137,7 +1345,7 @@ part001 = startSketchOn(XZ)
let segmentToDelete
const getOverlayByIndex = (index: number) =>
u.getBoundingBox(`[data-overlay-index="${index}"]`)
u.getBoundingBox(`[data - overlay - index="${index}"]`)
segmentToDelete = await getOverlayByIndex(14)
let ang = await u.getAngle('[data-overlay-index="14"]')
@ -1147,10 +1355,10 @@ part001 = startSketchOn(XZ)
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: `arc({
radius = 9.03,
angleStart = 40.27,
angleEnd = -38.05
}, %)`,
radius = 9.03,
angleStart = 40.27,
angleEnd = -38.05
}, %)`,
stdLibFnName: 'arc',
ang: ang + 180,
steps: 6,
@ -1161,9 +1369,9 @@ part001 = startSketchOn(XZ)
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: `arcTo({
interior = [16.25, 5.12],
end = [21.61, 4.15]
}, %)`,
interior =[16.25, 5.12],
end =[21.61, 4.15]
}, %)`,
stdLibFnName: 'arcTo',
ang: ang,
steps: 6,
@ -1185,10 +1393,10 @@ part001 = startSketchOn(XZ)
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: `angledLineThatIntersects({
angle = 4.14,
intersectTag = a,
offset = 9
}, %)`,
angle = 4.14,
intersectTag = a,
offset = 9
}, %)`,
stdLibFnName: 'angledLineThatIntersects',
ang: ang + 180,
steps: 7,
@ -1199,7 +1407,7 @@ part001 = startSketchOn(XZ)
ang = await u.getAngle('[data-overlay-index="10"]')
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: 'angledLineToY({ angle = 89, to = 9.14 + 0 }, %)',
codeToBeDeleted: 'angledLine(angle = 89, endAbsoluteY = 9.14 + 0)',
stdLibFnName: 'angledLineToY',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="10"]',
@ -1209,7 +1417,7 @@ part001 = startSketchOn(XZ)
ang = await u.getAngle('[data-overlay-index="9"]')
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: 'angledLineToX({ angle = 3 + 0, to = 26 }, %)',
codeToBeDeleted: 'angledLine(angle = 3 + 0, endAbsoluteX = 26)',
stdLibFnName: 'angledLineToX',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="9"]',
@ -1314,7 +1522,7 @@ part001 = startSketchOn(XZ)
ang = await u.getAngle('[data-overlay-index="1"]')
await deleteSegmentSequence({
hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
codeToBeDeleted: 'angledLine({ angle = 3 + 0, length = 32 + 0 }, %)',
codeToBeDeleted: 'angledLine(angle = 3 + 0, length = 32 + 0 )',
stdLibFnName: 'angledLine',
ang: ang + 180,
locator: '[data-overlay-toolbar-index="1"]',
@ -1335,25 +1543,25 @@ part001 = startSketchOn(XZ)
test.describe('Testing delete with dependent segments', () => {
const cases = [
'line(end = [22, 2], tag = $seg01)',
'angledLine([5, 23.03], %, $seg01)',
'angledLine(angle = 5, length = 23.03, tag = $seg01)',
'xLine(length = 23, tag = $seg01)',
'yLine(length = -8, tag = $seg01)',
'xLine(endAbsolute = 30, tag = $seg01)',
'yLine(endAbsolute = -4, tag = $seg01)',
'angledLineOfXLength([3, 30], %, $seg01)',
'angledLine(angle = 3, lengthX = 30, tag = $seg01)',
'angledLineOfXLength({ angle = 3, length = 30 }, %, $seg01)',
'angledLineOfYLength([3, 1.5], %, $seg01)',
'angledLine(angle = 3, lengthY = 1.5, tag = $seg01)',
'angledLineOfYLength({ angle = 3, length = 1.5 }, %, $seg01)',
'angledLineToX([3, 30], %, $seg01)',
'angledLineToX({ angle = 3, to = 30 }, %, $seg01)',
'angledLineToY([3, 7], %, $seg01)',
'angledLineToY({ angle = 3, to = 7 }, %, $seg01)',
'angledLine(angle = 3, endAbsoluteX = 30, tag = $seg01)',
'angledLine(angle = 3, endAbsoluteX = 30, tag = $seg01)',
'angledLine(angle = 3, endAbsoluteY = 7, tag = $seg01)',
'angledLine(angle = 3, endAbsoluteY = 7, tag = $seg01)',
]
for (const doesHaveTagOutsideSketch of [true, false]) {
for (const lineOfInterest of cases) {
const isObj = lineOfInterest.includes('{ angle = 3,')
test(`${lineOfInterest.split('=')[0]}${isObj ? '-[obj-input]' : ''}${
doesHaveTagOutsideSketch ? '-[tagOutsideSketch]' : ''
test(`${ lineOfInterest.split('=')[0] }${ isObj? '-[obj-input]': '' }${
doesHaveTagOutsideSketch? '-[tagOutsideSketch]': ''
}`, async ({ page, editor, homePage }) => {
await page.addInitScript(
async ({ lineToBeDeleted, extraLine }) => {
@ -1362,10 +1570,16 @@ part001 = startSketchOn(XZ)
`@settings(defaultLengthUnit = in)
part001 = startSketchOn(XZ)
|> startProfileAt([5, 6], %)
|> ${lineToBeDeleted}
|> ${ lineToBeDeleted }
|> line(end = [-10, -15])
|> angledLine([-176, segLen(seg01)], %)
${extraLine ? 'myVar = segLen(seg01)' : ''}`
<<<<<<< HEAD
|> angledLine([-176, segLen(seg01)], %)
||||||| parent of bcbec9f87 (Update KCL in JS project)
|> angledLine([-176, segLen(seg01)], %)
=======
|> angledLine(angle = -176, length = segLen(seg01))
>>>>>>> bcbec9f87 (Update KCL in JS project)
${ extraLine? 'myVar = segLen(seg01)': '' }`
)
},
{
@ -1403,7 +1617,7 @@ part001 = startSketchOn(XZ)
await expect(page.getByTestId('segment-overlay')).toHaveCount(3)
const segmentToDelete = await u.getBoundingBox(
`[data-overlay-index="0"]`
`[data - overlay - index= "0"]`
)
const isYLine = lineOfInterest.toLowerCase().includes('yline')
@ -1477,7 +1691,7 @@ part001 = startSketchOn(XZ)
},
{
before: `angledLine([5 + 0, 23.03 + 0], %, $seg01)`,
before: `angledLine(angle = 5 + 0, length = 23.03 + 0, tag = $seg01)`,
after: `line(end = [22.94, 2.01], tag = $seg01)`,
},
{
@ -1505,18 +1719,18 @@ part001 = startSketchOn(XZ)
after: `line(end = [28.62, 1.5], tag = $seg01)`,
},
{
before: `angledLineToX({ angle = 3 + 0, to = 30 + 0 }, %, $seg01)`,
before: `angledLine(angle = 3 + 0, endAbsoluteX = 30 + 0, tag = $seg01)`,
after: `line(end = [25, 1.31], tag = $seg01)`,
},
{
before: `angledLineToY({ angle = 3 + 0, to = 7 + 0 }, %, $seg01)`,
before: `angledLine(angle = 3 + 0, endAbsoluteY = 7 + 0, tag = $seg01)`,
after: `line(end = [19.08, 1], tag = $seg01)`,
},
]
for (const { before, after } of cases) {
const isObj = before.includes('{ angle = 3')
test(`${before.split('=')[0]}${isObj ? '-[obj-input]' : ''}`, async ({
test(`${ before.split('=')[0] }${ isObj? '-[obj-input]': '' }`, async ({
page,
editor,
homePage,
@ -1527,10 +1741,10 @@ part001 = startSketchOn(XZ)
'persistCode',
`@settings(defaultLengthUnit = in)
part001 = startSketchOn(XZ)
|> startProfileAt([5, 6], %)
|> ${lineToBeDeleted}
|> line(end = [-10, -15])
|> angledLine([-176, segLen(seg01)], %)`
|> startProfileAt([5, 6], %)
|> ${ lineToBeDeleted }
|> line(end = [-10, -15])
|> angledLine(angle = -176, length = segLen(seg01))`
)
},
{
@ -1552,7 +1766,7 @@ part001 = startSketchOn(XZ)
await expect(page.getByTestId('segment-overlay')).toHaveCount(3)
await expect(page.getByText('Added variable')).not.toBeVisible()
const hoverPos = await u.getBoundingBox(`[data-overlay-index="0"]`)
const hoverPos = await u.getBoundingBox(`[data - overlay - index="0"]`)
let ang = await u.getAngle('[data-overlay-index="0"]')
ang += 180

24
e2e/playwright/testing-selections.spec.ts
View File

@ -320,9 +320,9 @@ part009 = startSketchOn(XY)
|> line(end = [0, -1])
|> line(end = [-thickness, 0])
|> line(end = [0, 1])
|> angledLineToX({ angle = 120, to = pipeSmallDia }, %)
|> angledLine(angle = 120, endAbsoluteX = pipeSmallDia)
|> line(end = [0, pipeLength])
|> angledLineToX({ angle = 60, to = pipeLargeDia }, %)
|> angledLine(angle = 60, endAbsoluteX = pipeLargeDia)
|> close()
rev = revolve(part009, axis = 'y')
sketch006 = startSketchOn(XY)
@ -332,7 +332,7 @@ profile001 = circle(
radius = 17.96
)
profile002 = startProfileAt([86.92, -63.81], sketch006)
|> angledLine([0, 63.81], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 63.81, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
17.05
@ -471,7 +471,7 @@ yo = startProfileAt([4.83, 12.56], part001)
|> line(end = [15.1, 2.48])
|> line(end = [3.15, -9.85], tag = $seg01)
|> line(end = [-15.17, -4.1])
|> angledLine([segAng(seg01), 12.35], %, $seg02)
|> angledLine(angle = segAng(seg01), length = 12.35, tag = $seg02)
|> line(end = [-13.02, 10.03])
|> close()
yoo = extrude(yo, length = 4)
@ -484,7 +484,7 @@ profile002 = startProfileAt([-11.08, 2.39], sketch002)
|> close()
extrude001 = extrude(profile002, length = 15)
profile001 = startProfileAt([7.49, 9.96], sketch001)
|> angledLine([0, 5.05], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 5.05, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
4.81
@ -537,15 +537,15 @@ profile001 = startProfileAt([7.49, 9.96], sketch001)
part001 = startSketchOn(XZ)
|> startProfileAt([20, 0], %)
|> line(end = [7.13, 4 + 0])
|> angledLine({ angle = 3 + 0, length = 3.14 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 3.14 + 0 )
|> line(endAbsolute = [20.14 + 0, -0.14 + 0])
|> xLine(endAbsolute = 29 + 0)
|> yLine(length = -3.14 + 0, tag = $a)
|> xLine(length = 1.63)
|> angledLineOfXLength({ angle = 3 + 0, length = 3.14 }, %)
|> angledLineOfYLength({ angle = 30, length = 3 + 0 }, %)
|> angledLineToX({ angle = 22.14 + 0, to = 12 }, %)
|> angledLineToY({ angle = 30, to = 11.14 }, %)
|> angledLine(angle = 22.14 + 0, endAbsoluteX = 12)
|> angledLine(angle = 30, endAbsoluteY = 11.14)
|> angledLineThatIntersects({
angle = 3.14,
intersectTag = a,
@ -735,13 +735,13 @@ part001 = startSketchOn(XZ)
'straightSegmentEdge',
straightSegmentEdge,
`angledLineToY({angle=30,to=11.14},%)`,
'angledLineToY({ angle = 30, to = 11.14 }, %)'
'angledLine(angle = 30, endAbsoluteY = 11.14)'
)
await checkCodeAtHoverPosition(
'straightSegmentOppositeEdge',
straightSegmentOppositeEdge,
`angledLineToY({angle=30,to=11.14},%)`,
'angledLineToY({ angle = 30, to = 11.14 }, %)'
'angledLine(angle = 30, endAbsoluteY = 11.14)'
)
await checkCodeAtHoverPosition(
'straightSegmentAdjacentEdge',
@ -756,7 +756,7 @@ part001 = startSketchOn(XZ)
await u.codeLocator.fill(`@settings(defaultLengthUnit = in)
sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -961,7 +961,7 @@ part001 = startSketchOn(XZ)
},
{
pos: [816, 244],
expectedCode: 'angledLine([segAng(seg01), yo], %)',
expectedCode: 'angledLine(angle = segAng(seg01), length = yo)',
},
{
pos: [1107, 161],

2
e2e/playwright/testing-selections.spec.ts-snapshots/editor-content-Google-Chrome-darwin
View File

@ -1 +1 @@
part001 = startSketchOn('XY')yo = startProfileAt([4.83, 12.56], part001) |> line(end = [15.1, 2.48]) |> line(end = [3.15, -9.85], tag = $seg01) |> line(end = [-15.17, -4.1]) |> angledLine([segAng(seg01), 12.35], %, $seg02) |> line(end = [-13.02, 10.03]) |> close()sketch002 = startSketchOn({ plane = { origin = { x = 7.49, y = 2.4, z = 0 }, xAxis = { x = -0.3, y = 0.95, z = 0 }, yAxis = { x = 0, y = 0, z = 1 }, zAxis = { x = 0.95, y = 0.3, z = 0 } }})sketch001 = startSketchOn({ plane = { origin = { x = 0, y = 0, z = 4 }, xAxis = { x = 1, y = 0, z = 0 }, yAxis = { x = 0, y = 1, z = 0 }, zAxis = { x = 0, y = 0, z = 1 } }})profile002 = startProfileAt([-11.08, 2.39], sketch002) |> line(end = [4.89, 0.9]) |> line(end = [-0.61, -2.41]) |> line(endAbsolute = [profileStartX(%), profileStartY(%)]) |> close()extrude001 = extrude(profile002, length = 15)profile001 = startProfileAt([7.49, 9.96], sketch001) |> angledLine([0, 5.05], %, $rectangleSegmentA001) |> angledLine([ segAng(rectangleSegmentA001) - 90, 4.81 ], %) |> angledLine([ segAng(rectangleSegmentA001), -segLen(rectangleSegmentA001) ], %) |> line(endAbsolute = [profileStartX(%), profileStartY(%)]) |> close()
part001 = startSketchOn('XY')yo = startProfileAt([4.83, 12.56], part001) |> line(end = [15.1, 2.48]) |> line(end = [3.15, -9.85], tag = $seg01) |> line(end = [-15.17, -4.1]) |> angledLine(angle = segAng(seg01), 12.35], %, $seg02) |> line(end = [-13.02, 10.03]) |> close()sketch002 = startSketchOn({ plane = { origin = { x = 7.49, y = 2.4, z = 0 }, xAxis = { x = -0.3, y = 0.95, z = 0 }, yAxis = { x = 0, y = 0, z = 1 }, zAxis = { x = 0.95, y = 0.3, z = 0 } }})sketch001 = startSketchOn({ plane = { origin = { x = 0, y = 0, z = 4 }, xAxis = { x = 1, y = 0, z = 0 }, yAxis = { x = 0, y = 1, z = 0 }, zAxis = { x = 0, y = 0, z = 1 } }})profile002 = startProfileAt([-11.08, 2.39], sketch002) |> line(end = [4.89, 0.9]) |> line(end = [-0.61, -2.41]) |> line(endAbsolute = [profileStartX(%), profileStartY(%)]) |> close()extrude001 = extrude(profile002, length = 15)profile001 = startProfileAt([7.49, 9.96], sketch001) |> angledLine(angle = 0, length = 5.05, tag = $rectangleSegmentA001) |> angledLine([ segAng(rectangleSegmentA001) - 90, 4.81 ], %) |> angledLine([ segAng(rectangleSegmentA001), length = -segLen(rectangleSegmentA001) ) |> line(endAbsolute = [profileStartX(%), profileStartY(%)]) |> close()

20
e2e/playwright/various.spec.ts
View File

@ -45,7 +45,7 @@ test(
// And you will need to have the KittyCAD CLI installed
const u = await getUtils(page)
await page.addInitScript(async () => {
;(window as any).playwrightSkipFilePicker = true
; (window as any).playwrightSkipFilePicker = true
localStorage.setItem(
'persistCode',
`topAng = 25
@ -59,10 +59,11 @@ part001 = startSketchOn(-XZ)
|> startProfileAt([0, 0], %)
|> yLine(length = baseHeight)
|> xLine(length = baseLen)
|> angledLineToY({
|> angledLine(
angle = topAng,
to = totalHeightHalf,
}, %, $seg04)
endAbsoluteY = totalHeightHalf,
tag = $seg04,
)
|> xLine(endAbsolute = totalLen, tag = $seg03)
|> yLine(length = -armThick, tag = $seg01)
|> angledLineThatIntersects({
@ -70,11 +71,12 @@ part001 = startSketchOn(-XZ)
offset = -armThick,
intersectTag = seg04
}, %)
|> angledLineToY([segAng(seg04) + 180, turns::ZERO], %)
|> angledLineToY({
|> angledLine(angle = segAng(seg04) + 180, endAbsoluteY = turns::ZERO)
|> angledLine(
angle = -bottomAng,
to = -totalHeightHalf - armThick,
}, %, $seg02)
endAbsoluteY = -totalHeightHalf - armThick,
tag = $seg02,
)
|> xLine(endAbsolute = segEndX(seg03) + 0)
|> yLine(length = -segLen(seg01))
|> angledLineThatIntersects({
@ -82,7 +84,7 @@ part001 = startSketchOn(-XZ)
offset = -armThick,
intersectTag = seg02
}, %)
|> angledLineToY([segAng(seg02) + 180, -baseHeight], %)
|> angledLine(angle = segAng(seg02) + 180, endAbsoluteY = -baseHeight)
|> xLine(endAbsolute = turns::ZERO)
|> close()
|> extrude(length = 4)`

2
public/kcl-samples/gridfinity-bins-stacking-lip/main.kcl
View File

@ -187,7 +187,7 @@ fn lipFace(plane) {
angleEnd = 45.0,
radius = 0.500000
}, %, $arc000)
// |> angledLineOfYLength({ angle: -45, length: lipStep5 }, %)
// |> angledLine(angle = -45, lengthY = lipStep5 )
|> line(end = [1.046447, -1.046447], tag = $line001)
|> yLine(length = -lipStep4)
|> angledLine(angle = -45, lengthY = lipStep3)

2
rust/kcl-lib/e2e/executor/inputs/e2e-can-sketch-on-chamfer-no-pipeExpr.kcl
View File

@ -1,7 +1,7 @@
@settings(defaultLengthUnit = in)
sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %)
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26

2
rust/kcl-lib/e2e/executor/inputs/e2e-can-sketch-on-chamfer.kcl
View File

@ -1,7 +1,7 @@
@settings(defaultLengthUnit = in)
sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26

68
rust/kcl-lib/e2e/executor/inputs/server-rack-heavy.kcl
View File

@ -647,7 +647,7 @@ const planeYZfl = {
// Base flange
const sketch001fl = startSketchOn(planeXZfl)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001fl)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001fl)
|> angledLine([
segAng(rectangleSegmentA001fl) + 90,
railHeight * 1.75
@ -663,7 +663,7 @@ const extrude001fl = extrude(sketch001fl, length = thickness)
// First flange
const sketch002fl = startSketchOn(planeYZfl)
|> startProfileAt([-bendRad - thickness, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002fl)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002fl)
|> angledLine([
segAng(rectangleSegmentA002fl) - 90,
railHeight * 1.75
@ -699,7 +699,7 @@ const extrude003fl = extrude(sketch003fl, length = railHeight * 1.75)
// EIA-310-D standard hole pattern
const sketch004fl = startSketchOn(extrude002fl, 'START')
|> startProfileAt([0.72 + originStart[1], originStart[2] + 0.15], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA003fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA003fl)
|> angledLine([
segAng(rectangleSegmentA003fl) - 90,
0.375
@ -720,7 +720,7 @@ const extrude004fl = extrude(sketch004fl, length = -thickness)
// EIA-310-D standard hole pattern
const sketch005fl = startSketchOn(extrude002fl, 'START')
|> startProfileAt([0.72 + originStart[1],originStart[2] + 0.15 + .62], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA004fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA004fl)
|> angledLine([
segAng(rectangleSegmentA004fl) - 90,
0.375
@ -744,7 +744,7 @@ const sketch006fl = startSketchOn(extrude002fl, 'START')
0.72 + originStart[1],
originStart[2] + 0.15 + 0.62 + 0.50
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA005fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA005fl)
|> angledLine([
segAng(rectangleSegmentA005fl) - 90,
0.375
@ -765,7 +765,7 @@ const extrude006fl = extrude(sketch006fl, length = -thickness)
// EIA-310-D standard hole pattern
const sketch007fl = startSketchOn(extrude001fl, 'START')
|> startProfileAt([-1.45 - originStart[0], originStart[2] + 0.15], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA006fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA006fl)
|> angledLine([
segAng(rectangleSegmentA006fl) - 90,
0.375
@ -786,7 +786,7 @@ const extrude007fl = extrude(sketch007fl, length = -thickness)
// EIA-310-D standard hole pattern
const sketch008fl = startSketchOn(extrude001fl, 'START')
|> startProfileAt([-1.45 - originStart[0],originStart[2] + 0.15 + 0.62], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA007fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA007fl)
|> angledLine([
segAng(rectangleSegmentA007fl) - 90,
0.375
@ -810,7 +810,7 @@ const sketch009fl = startSketchOn(extrude001fl, 'START')
-1.45 - originStart[0],
originStart[2] + 0.15 + 0.62 + 0.5
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA008fl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA008fl)
|> angledLine([
segAng(rectangleSegmentA008fl) - 90,
0.375
@ -924,7 +924,7 @@ const planeYZfr = {
// Base flange
const sketch001fr = startSketchOn(planeXZfr)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001fr)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001fr)
|> angledLine([
segAng(rectangleSegmentA001fr) + 90,
railHeight * 1.75
@ -940,7 +940,7 @@ const extrude001fr = extrude(sketch001fr, length = thickness)
// First flange
const sketch002fr = startSketchOn(planeYZfr)
|> startProfileAt([0.89, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002fr)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002fr)
|> angledLine([
segAng(rectangleSegmentA002fr) - 90,
railHeight * 1.75
@ -981,7 +981,7 @@ const sketch004fr = startSketchOn(extrude002fr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA003fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA003fr)
|> angledLine([
segAng(rectangleSegmentA003fr) - 90,
0.375
@ -1005,7 +1005,7 @@ const sketch005fr = startSketchOn(extrude002fr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15 + .62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA004fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA004fr)
|> angledLine([
segAng(rectangleSegmentA004fr) - 90,
0.375
@ -1029,7 +1029,7 @@ const sketch006fr = startSketchOn(extrude002fr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15 + 0.62 + 0.50
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA005fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA005fr)
|> angledLine([
segAng(rectangleSegmentA005fr) - 90,
0.375
@ -1053,7 +1053,7 @@ const sketch007fr = startSketchOn(extrude001fr, 'START')
-1.45 - originStart[0],
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA006fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA006fr)
|> angledLine([
segAng(rectangleSegmentA006fr) - 90,
0.375
@ -1077,7 +1077,7 @@ const sketch008fr = startSketchOn(extrude001fr, 'START')
-1.45 - originStart[0],
originStart[2] + 0.15 + 0.62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA007fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA007fr)
|> angledLine([
segAng(rectangleSegmentA007fr) - 90,
0.375
@ -1101,7 +1101,7 @@ const sketch009fr = startSketchOn(extrude001fr, 'START')
-1.45 - originStart[0],
originStart[2] + 0.15 + 0.62 + 0.5
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA008fr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA008fr)
|> angledLine([
segAng(rectangleSegmentA008fr) - 90,
0.375
@ -1218,7 +1218,7 @@ const planeYZrr = {
// Base flange
const sketch001rr = startSketchOn(planeXZrr)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001rr)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001rr)
|> angledLine([
segAng(rectangleSegmentA001rr) + 90,
railHeight * 1.75
@ -1234,7 +1234,7 @@ const extrude001rr = extrude(sketch001rr, length = thickness)
// First flange
const sketch002rr = startSketchOn(planeYZrr)
|> startProfileAt([0.89, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002rr)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002rr)
|> angledLine([
segAng(rectangleSegmentA002rr) - 90,
railHeight * 1.75
@ -1275,7 +1275,7 @@ const sketch004rr = startSketchOn(extrude002rr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA003rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA003rr)
|> angledLine([
segAng(rectangleSegmentA003rr) - 90,
0.375
@ -1299,7 +1299,7 @@ const sketch005rr = startSketchOn(extrude002rr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15 + .62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA004rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA004rr)
|> angledLine([
segAng(rectangleSegmentA004rr) - 90,
0.375
@ -1323,7 +1323,7 @@ const sketch006rr = startSketchOn(extrude002rr, 'START')
-0.35 + originStart[1] + width - 2,
originStart[2] + 0.15 + 0.62 + 0.50
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA005rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA005rr)
|> angledLine([
segAng(rectangleSegmentA005rr) - 90,
0.375
@ -1347,7 +1347,7 @@ const sketch007rr = startSketchOn(extrude001rr, 'START')
-originStart[0]-serverDepth+1.7,
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA006rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA006rr)
|> angledLine([
segAng(rectangleSegmentA006rr) - 90,
0.375
@ -1371,7 +1371,7 @@ const sketch008rr = startSketchOn(extrude001rr, 'START')
-originStart[0]-serverDepth+1.7,
originStart[2] + 0.15 + 0.62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA007rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA007rr)
|> angledLine([
segAng(rectangleSegmentA007rr) - 90,
0.375
@ -1395,7 +1395,7 @@ const sketch009rr = startSketchOn(extrude001rr, 'START')
-originStart[0]-serverDepth+1.7,
originStart[2] + 0.15 + 0.62 + 0.5
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA008rr)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA008rr)
|> angledLine([
segAng(rectangleSegmentA008rr) - 90,
0.375
@ -1511,7 +1511,7 @@ const planeYZrl = {
// Base flange
const sketch001rl = startSketchOn(planeXZrl)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001rl)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001rl)
|> angledLine([
segAng(rectangleSegmentA001rl) + 90,
railHeight * 1.75
@ -1527,7 +1527,7 @@ const extrude001rl = extrude(sketch001rl, length = thickness)
// First flange
const sketch002rl = startSketchOn(planeYZrl)
|> startProfileAt([-bendRad - thickness, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002rl)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002rl)
|> angledLine([
segAng(rectangleSegmentA002rl) - 90,
railHeight * 1.75
@ -1568,7 +1568,7 @@ const sketch004rl = startSketchOn(extrude002rl, 'START')
-1.38 + 2 + thickness + originStart[1],
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA003rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA003rl)
|> angledLine([
segAng(rectangleSegmentA003rl) - 90,
0.375
@ -1592,7 +1592,7 @@ const sketch005rl = startSketchOn(extrude002rl, 'START')
-1.38 + 2 + thickness + originStart[1],
originStart[2] + 0.15 + .62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA004rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA004rl)
|> angledLine([
segAng(rectangleSegmentA004rl) - 90,
0.375
@ -1616,7 +1616,7 @@ const sketch006rl = startSketchOn(extrude002rl, 'START')
-1.38 + 2 + thickness + originStart[1],
originStart[2] + 0.15 + 0.62 + 0.50
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA005rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA005rl)
|> angledLine([
segAng(rectangleSegmentA005rl) - 90,
0.375
@ -1640,7 +1640,7 @@ const sketch007rl = startSketchOn(extrude001rl, 'START')
1.75 - originStart[0] - serverDepth,
originStart[2] + 0.15
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA006rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA006rl)
|> angledLine([
segAng(rectangleSegmentA006rl) - 90,
0.375
@ -1664,7 +1664,7 @@ const sketch008rl = startSketchOn(extrude001rl, 'START')
1.75 - originStart[0] - serverDepth,
originStart[2] + 0.15 + 0.62
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA007rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA007rl)
|> angledLine([
segAng(rectangleSegmentA007rl) - 90,
0.375
@ -1688,7 +1688,7 @@ const sketch009rl = startSketchOn(extrude001rl, 'START')
1.75 - originStart[0] - serverDepth,
originStart[2] + 0.15 + 0.62 + 0.5
], %)
|> angledLine([0, -0.375], %, $rectangleSegmentA008rl)
|> angledLine(angle = 0, length = -0.375, tag = $rectangleSegmentA008rl)
|> angledLine([
segAng(rectangleSegmentA008rl) - 90,
0.375
@ -1796,8 +1796,8 @@ fn streamServer = (serverPos) => {
const sketch001s = startSketchOn(planeXYs)
|> startProfileAt([1 + 1.2, 1], %)
|> angledLine([0, 17.2], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) + 90, 29], %, $rectangleSegmentB001)
|> angledLine(angle = 0, length = 17.2, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) + 90, length = 29, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)

20
rust/kcl-lib/e2e/executor/inputs/server-rack-lite.kcl
View File

@ -653,7 +653,7 @@ const planeYZfl = {
// Base flange
const sketch001fl = startSketchOn(planeXZfl)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001fl)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001fl)
|> angledLine([
segAng(rectangleSegmentA001fl) + 90,
railHeight * 1.75
@ -669,7 +669,7 @@ const extrude001fl = extrude(sketch001fl, length = thickness)
// First flange
const sketch002fl = startSketchOn(planeYZfl)
|> startProfileAt([-bendRad - thickness, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002fl)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002fl)
|> angledLine([
segAng(rectangleSegmentA002fl) - 90,
railHeight * 1.75
@ -804,7 +804,7 @@ const planeYZfr = {
// Base flange
const sketch001fr = startSketchOn(planeXZfr)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001fr)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001fr)
|> angledLine([
segAng(rectangleSegmentA001fr) + 90,
railHeight * 1.75
@ -820,7 +820,7 @@ const extrude001fr = extrude(sketch001fr, length = thickness)
// First flange
const sketch002fr = startSketchOn(planeYZfr)
|> startProfileAt([0.89, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002fr)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002fr)
|> angledLine([
segAng(rectangleSegmentA002fr) - 90,
railHeight * 1.75
@ -954,7 +954,7 @@ const planeYZrr = {
// Base flange
const sketch001rr = startSketchOn(planeXZrr)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001rr)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001rr)
|> angledLine([
segAng(rectangleSegmentA001rr) + 90,
railHeight * 1.75
@ -970,7 +970,7 @@ const extrude001rr = extrude(sketch001rr, length = thickness)
// First flange
const sketch002rr = startSketchOn(planeYZrr)
|> startProfileAt([0.89, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002rr)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002rr)
|> angledLine([
segAng(rectangleSegmentA002rr) - 90,
railHeight * 1.75
@ -1103,7 +1103,7 @@ const planeYZrl = {
// Base flange
const sketch001rl = startSketchOn(planeXZrl)
|> startProfileAt([bendRad + thickness, 0], %)
|> angledLine([0, 2 - bendRad - thickness], %, $rectangleSegmentA001rl)
|> angledLine(angle = 0, length = 2 - bendRad - thickness, tag = $rectangleSegmentA001rl)
|> angledLine([
segAng(rectangleSegmentA001rl) + 90,
railHeight * 1.75
@ -1119,7 +1119,7 @@ const extrude001rl = extrude(sketch001rl, length = thickness)
// First flange
const sketch002rl = startSketchOn(planeYZrl)
|> startProfileAt([-bendRad - thickness, 0], %)
|> angledLine([180, 0.89 - bendRad - thickness], %, $rectangleSegmentA002rl)
|> angledLine(angle = 180, length = 0.89 - bendRad - thickness, tag = $rectangleSegmentA002rl)
|> angledLine([
segAng(rectangleSegmentA002rl) - 90,
railHeight * 1.75
@ -1243,8 +1243,8 @@ fn streamServer = (serverPos) => {
const sketch001s = startSketchOn(planeXYs)
|> startProfileAt([1 + 1.2, 1], %)
|> angledLine([0, 17.2], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) + 90, 29], %, $rectangleSegmentB001)
|> angledLine(angle = 0, length = 17.2, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) + 90, length = 29, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)

6
rust/kcl-lib/e2e/executor/inputs/sketch-on-chamfer-two-times-different-order.kcl
View File

@ -1,6 +1,6 @@
const sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -22,7 +22,7 @@ const extrude001 = extrude(sketch001, length = 100)
const sketch003 = startSketchOn(extrude001, seg04)
|> startProfileAt([-69.1, 277.34], %)
|> angledLine([0, 41.48], %, $rectangleSegmentA003)
|> angledLine(angle = 0, length = 41.48, tag = $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
104.8
@ -35,7 +35,7 @@ const sketch003 = startSketchOn(extrude001, seg04)
|> close()
const sketch002 = startSketchOn(extrude001, seg03)
|> startProfileAt([159.25, 278.35], %)
|> angledLine([0, 40.82], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 40.82, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
132.27

6
rust/kcl-lib/e2e/executor/inputs/sketch-on-chamfer-two-times.kcl
View File

@ -1,6 +1,6 @@
const sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -22,7 +22,7 @@ const extrude001 = extrude(sketch001, length = 100)
const sketch003 = startSketchOn(extrude001, seg04)
|> startProfileAt([-69.1, 277.34], %)
|> angledLine([0, 41.48], %, $rectangleSegmentA003)
|> angledLine(angle = 0, length = 41.48, tag = $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
104.8
@ -35,7 +35,7 @@ const sketch003 = startSketchOn(extrude001, seg04)
|> close()
const sketch002 = startSketchOn(extrude001, seg03)
|> startProfileAt([159.25, 278.35], %)
|> angledLine([0, 40.82], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 40.82, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
132.27

2
rust/kcl-lib/e2e/executor/inputs/test-circle-extrude.kcl
View File

@ -1,6 +1,6 @@
sketch002 = startSketchOn(XZ)
|> startProfileAt([-108.83, -57.48], %)
|> angledLine([0, 105.13], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 105.13, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
77.9

4
rust/kcl-lib/src/unparser.rs
View File

@ -1203,7 +1203,7 @@ fn o(c_x, c_y) {
angle_start = 45 + a,
angle_end = 225 - a
}, %)
|> angledLine([45, o_r - i_r], %)
|> angledLine(angle = 45, length = o_r - i_r)
|> arc({
radius = i_r,
angle_start = 225 - a,
@ -1219,7 +1219,7 @@ fn o(c_x, c_y) {
angle_start = 225 + a,
angle_end = 360 + 45 - a
}, %)
|> angledLine([225, o_r - i_r], %)
|> angledLine(angle = 225, length = o_r - i_r)
|> arc({
radius = i_r,
angle_start = 45 - a,

2
rust/kcl-lib/tests/kcl_samples/gridfinity-bins-stacking-lip/ast.snap
View File

@ -5344,7 +5344,7 @@ description: Result of parsing gridfinity-bins-stacking-lip.kcl
"type": "NonCodeNode",
"value": {
"type": "blockComment",
"value": "|> angledLineOfYLength({ angle: -45, length: lipStep5 }, %)",
"value": "|> angledLine(angle = -45, lengthY = lipStep5 )",
"style": "line"
}
}

64
src/lang/modifyAst.test.ts
View File

@ -322,11 +322,11 @@ yo = 5 + 6
part001 = startSketchOn(XY)
|> startProfileAt([-1.2, 4.83], %)
|> line(end = [2.8, 0])
|> angledLine([100 + 100, 3.09], %)
|> angledLine([abc, 3.09], %)
|> angledLine([def(yo), 3.09], %)
|> angledLine([ghi(%), 3.09], %)
|> angledLine([jkl(yo) + 2, 3.09], %)
|> angledLine(angle = 100 + 100, length = 3.09)
|> angledLine(angle = abc, length = 3.09)
|> angledLine(angle = def(yo), length = 3.09)
|> angledLine(angle = ghi(%), length = 3.09)
|> angledLine(angle = jkl(yo) + 2, length = 3.09)
yo2 = hmm([identifierGuy + 5])`
it('should move a binary expression into a new variable', async () => {
const ast = assertParse(code)
@ -340,7 +340,7 @@ yo2 = hmm([identifierGuy + 5])`
)
const newCode = recast(modifiedAst)
expect(newCode).toContain(`newVar = 100 + 100`)
expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
expect(newCode).toContain(`angledLine(angle = newVar, length = 3.09)`)
})
it('should move a value into a new variable', async () => {
const ast = assertParse(code)
@ -368,7 +368,7 @@ yo2 = hmm([identifierGuy + 5])`
)
const newCode = recast(modifiedAst)
expect(newCode).toContain(`newVar = def(yo)`)
expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
expect(newCode).toContain(`angledLine(angle = newVar, length = 3.09)`)
})
it('should move a binary expression with call expression into a new variable', async () => {
const ast = assertParse(code)
@ -382,7 +382,7 @@ yo2 = hmm([identifierGuy + 5])`
)
const newCode = recast(modifiedAst)
expect(newCode).toContain(`newVar = jkl(yo) + 2`)
expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
expect(newCode).toContain(`angledLine(angle = newVar, length = 3.09)`)
})
it('should move a identifier into a new variable', async () => {
const ast = assertParse(code)
@ -600,7 +600,7 @@ ${!replace1 ? ` |> ${line}\n` : ''} |> angledLine([-65, ${
!replace1 ? 'segLen(a)' : replace1
}], %)
|> line(end = [306.21, 198.87])
|> angledLine([65, ${!replace2 ? 'segAng(a)' : replace2}], %)
|> angledLine(angle = 65, length = ${!replace2 ? 'segAng(a)' : replace2})
|> line(end = [-963.39, -154.67])
`
test.each([
@ -616,7 +616,7 @@ ${!replace1 ? ` |> ${line}\n` : ''} |> angledLine([-65, ${
['xLineTo', 'xLine(endAbsolute = 198.85, tag = $a)', ['162.14', '180']],
[
'angledLine',
'angledLine({ angle: 45.5, length: 198.85 }, %, $a)',
'angledLine(angle = 45.5, length = 198.85 , tag = $a)',
['198.85', '45.5'],
],
[
@ -631,12 +631,12 @@ ${!replace1 ? ` |> ${line}\n` : ''} |> angledLine([-65, ${
],
[
'angledLineToX',
'angledLineToX({ angle = 45.5, to = 198.85 }, %, $a)',
'angledLine(angle = 45.5, endAbsoluteX = 198.85, tag = $a)',
['231.33', '134.5'],
],
[
'angledLineToY',
'angledLineToY({ angle = 45.5, to = 198.85 }, %, $a)',
'angledLine(angle = 45.5, endAbsoluteY = 198.85, tag = $a)',
['134.51', '45.5'],
],
[
@ -674,7 +674,7 @@ describe('Testing removeSingleConstraintInfo', () => {
const code = `part001 = startSketchOn(-XZ)
|> startProfileAt([0, 0], %)
|> line(end = [3 + 0, 4 + 0])
|> angledLine({ angle = 3 + 0, length = 3.14 + 0 }, %)
|> angledLine(angle = 3 + 0, length = 3.14 + 0 )
|> line(endAbsolute = [6.14 + 0, 3.14 + 0])
|> xLine(/*xAbs*/ endAbsolute = 8 + 0)
|> yLine(/*yAbs*/ endAbsolute = 5 + 0)
@ -682,8 +682,8 @@ describe('Testing removeSingleConstraintInfo', () => {
|> xLine(/*xRel*/ length = 3.14 + 0)
|> angledLineOfXLength({ angle = 3 + 0, length = 3.14 + 0 }, %)
|> angledLineOfYLength({ angle = 30 + 0, length = 3 + 0 }, %)
|> angledLineToX({ angle = 12.14 + 0, to = 12 + 0 }, %)
|> angledLineToY({ angle = 30 + 0, to = 10.14 + 0 }, %)
|> angledLine(angle = 12.14 + 0, endAbsoluteX = 12 + 0)
|> angledLine(angle = 30 + 0, endAbsoluteY = 10.14 + 0)
|> angledLineThatIntersects({
angle = 3.14 + 0,
intersectTag = a,
@ -693,7 +693,7 @@ describe('Testing removeSingleConstraintInfo', () => {
test.each([
[' line(end = [3 + 0, 4])', 'arrayIndex', 1, ''],
[
'angledLine({ angle = 3, length = 3.14 + 0 }, %)',
'angledLine(angle = 3, length = 3.14 + 0 )',
'objectProperty',
'angle',
'',
@ -716,13 +716,13 @@ describe('Testing removeSingleConstraintInfo', () => {
'',
],
[
'angledLineToX({ angle = 12.14 + 0, to = 12 }, %)',
'angledLine(angle = 12.14 + 0, endAbsoluteX = 12)',
'objectProperty',
'to',
'',
],
[
'angledLineToY({ angle = 30, to = 10.14 + 0 }, %)',
'angledLine(angle = 30, endAbsoluteY = 10.14 + 0)',
'objectProperty',
'angle',
'',
@ -784,17 +784,17 @@ describe('Testing removeSingleConstraintInfo', () => {
describe('with array notation', () => {
const code = `part001 = startSketchOn(-XZ)
|> startProfileAt([0, 0], %)
|> angledLine([3.14 + 0, 3.14 + 0], %)
|> angledLineOfXLength([3 + 0, 3.14 + 0], %)
|> angledLineOfYLength([30 + 0, 3 + 0], %)
|> angledLineToX([12.14 + 0, 12 + 0], %)
|> angledLineToY([30 + 0, 10.14 + 0], %)`
|> angledLine(angle = 3.14 + 0, length = 3.14 + 0)
|> angledLine(angle = 3 + 0, lengthX = 3.14 + 0)
|> angledLine(angle = 30 + 0, lengthY = 3 + 0)
|> angledLine(angle = 12.14 + 0, endAbsoluteX = 12 + 0)
|> angledLine(angle = 30 + 0, endAbsoluteY = 10.14 + 0)`
test.each([
['angledLine([3, 3.14 + 0], %)', 'arrayIndex', 0],
['angledLineOfXLength([3, 3.14 + 0], %)', 'arrayIndex', 0],
['angledLineOfYLength([30 + 0, 3], %)', 'arrayIndex', 1],
['angledLineToX([12.14 + 0, 12], %)', 'arrayIndex', 1],
['angledLineToY([30, 10.14 + 0], %)', 'arrayIndex', 0],
['angledLine(angle = 3, length = 3.14 + 0)', 'arrayIndex', 0],
['angledLine(angle = 3, lengthX = 3.14 + 0)', 'arrayIndex', 0],
['angledLine(angle = 30 + 0, lengthY = 3)', 'arrayIndex', 1],
['angledLine(angle = 12.14 + 0, endAbsoluteX = 12)', 'arrayIndex', 1],
['angledLine(angle = 30, endAbsoluteY = 10.14 + 0)', 'arrayIndex', 0],
])('stdlib fn: %s', async (expectedFinish, key, value) => {
const ast = assertParse(code)
@ -896,7 +896,7 @@ sketch003 = startSketchOn(XZ)
// |> startProfileAt([-12.55, 2.89], %)
// |> line(end = [3.02, 1.9])
// |> line(end = [1.82, -1.49], tag = $seg02)
// |> angledLine([-86, segLen(seg02)], %)
// |> angledLine(angle = -86, length = segLen(seg02))
// |> line(end = [-3.97, -0.53])
// |> line(end = [0.3, 0.84])
// |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
@ -923,7 +923,7 @@ sketch003 = startSketchOn(XZ)
// |> startProfileAt([-12.55, 2.89], %)
// |> line(end = [3.02, 1.9])
// |> line(end = [1.82, -1.49], tag = $seg02)
// |> angledLine([-86, segLen(seg02)], %)
// |> angledLine(angle = -86, length = segLen(seg02))
// |> line(end = [-3.97, -0.53])
// |> line(end = [0.3, 0.84])
// |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
@ -952,7 +952,7 @@ sketch003 = startSketchOn(XZ)
// |> startProfileAt([-12.55, 2.89], %)
// |> line(end = [3.02, 1.9])
// |> line(end = [1.82, -1.49], tag = $seg02)
// |> angledLine([-86, segLen(seg02)], %)
// |> angledLine(angle = -86, length = segLen(seg02))
// |> line(end = [-3.97, -0.53])
// |> line(end = [0.3, 0.84])
// |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
@ -979,7 +979,7 @@ sketch003 = startSketchOn(XZ)
// |> startProfileAt([-12.55, 2.89], %)
// |> line(end = [3.02, 1.9])
// |> line(end = [1.82, -1.49], tag = $seg02)
// |> angledLine([-86, segLen(seg02)], %)
// |> angledLine(angle = -86, length = segLen(seg02))
// |> line(end = [-3.97, -0.53])
// |> line(end = [0.3, 0.84])
// |> line(endAbsolute = [profileStartX(%), profileStartY(%)])

28
src/lang/queryAst.test.ts
View File

@ -77,11 +77,11 @@ describe('testing argIsNotIdentifier', () => {
const code = `part001 = startSketchOn(XY)
|> startProfileAt([-1.2, 4.83], %)
|> line(end = [2.8, 0])
|> angledLine([100 + 100, 3.09], %)
|> angledLine([abc, 3.09], %)
|> angledLine([def('yo'), 3.09], %)
|> angledLine([ghi(%), 3.09], %)
|> angledLine([jkl('yo') + 2, 3.09], %)
|> angledLine(angle = 100 + 100, length = 3.09)
|> angledLine(angle = abc, length = 3.09)
|> angledLine(angle = def('yo'), length = 3.09)
|> angledLine(angle = ghi(%), length = 3.09)
|> angledLine(angle = jkl('yo') + 2, length = 3.09)
yo = 5 + 6
yo2 = hmm([identifierGuy + 5])`
it('find a safe binaryExpression', () => {
@ -98,7 +98,7 @@ yo2 = hmm([identifierGuy + 5])`
const replaced = result.replacer(structuredClone(ast), 'replaceName')
if (err(replaced)) throw replaced
const outCode = recast(replaced.modifiedAst)
expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
expect(outCode).toContain(`angledLine(angle = replaceName, length = 3.09)`)
})
it('find a safe Identifier', () => {
const ast = assertParse(code)
@ -126,7 +126,7 @@ yo2 = hmm([identifierGuy + 5])`
const replaced = result.replacer(structuredClone(ast), 'replaceName')
if (err(replaced)) throw replaced
const outCode = recast(replaced.modifiedAst)
expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
expect(outCode).toContain(`angledLine(angle = replaceName, length = 3.09)`)
})
it('find an UNsafe CallExpression, as it has a PipeSubstitution', () => {
const ast = assertParse(code)
@ -185,7 +185,7 @@ yo2 = hmm([identifierGuy + 5])`
if (err(replaced)) throw replaced
const { modifiedAst } = replaced
const outCode = recast(modifiedAst)
expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
expect(outCode).toContain(`angledLine(angle = replaceName, length = 3.09)`)
})
it('find a safe BinaryExpression within a CallExpression', () => {
const ast = assertParse(code)
@ -381,9 +381,9 @@ describe('testing hasExtrudeSketch', () => {
part001 = startSketchOn(XY)
|> startProfileAt([-1.41, 3.46], %)
|> line(end = [19.49, 1.16], tag = $seg01)
|> angledLine([-35, length001], %)
|> angledLine(angle = -35, length = length001)
|> line(end = [-3.22, -7.36])
|> angledLine([-175, segLen(seg01)], %)`
|> angledLine(angle = -175, length = segLen(seg01))`
const ast = assertParse(exampleCode)
const execState = await enginelessExecutor(ast)
@ -401,9 +401,9 @@ part001 = startSketchOn(XY)
part001 = startSketchOn(XY)
|> startProfileAt([-1.41, 3.46], %)
|> line(end = [19.49, 1.16], tag = $seg01)
|> angledLine([-35, length001], %)
|> angledLine(angle = -35, length = length001)
|> line(end = [-3.22, -7.36])
|> angledLine([-175, segLen(seg01)], %)
|> angledLine(angle = -175, length = segLen(seg01))
|> extrude(length = 1)`
const ast = assertParse(exampleCode)
@ -438,9 +438,9 @@ describe('Testing findUsesOfTagInPipe', () => {
|> startProfileAt([68.12, 156.65], %)
|> line(end = [306.21, 198.82])
|> line(end = [306.21, 198.85], tag = $seg01)
|> angledLine([-65, segLen(seg01)], %)
|> angledLine(angle = -65, length = segLen(seg01))
|> line(end = [306.21, 198.87])
|> angledLine([65, segLen(seg01)], %)`
|> angledLine(angle = 65, length = segLen(seg01))`
it('finds the current segment', async () => {
const ast = assertParse(exampleCode)

18
src/lang/std/sketch.test.ts
View File

@ -273,7 +273,7 @@ describe('testing addTagForSketchOnFace', () => {
it(`can break up chamfers in order to add tags - ${desc}`, async () => {
const genCode = (insertCode: string) => `sketch001 = startSketchOn(XZ)
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine(angle = 0, length = 268.43, tag = $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
@ -701,16 +701,16 @@ describe('testing getConstraintInfo', () => {
const code = `const part001 = startSketchOn(-XZ)
|> startProfileAt([0, 0], %)
|> line(end = [3, 4])
|> angledLine([3.14, 3.14], %)
|> angledLine(angle = 3.14, length = 3.14)
|> line(endAbsolute = [6.14, 3.14])
|> xLine(endAbsolute = 8)
|> yLine(endAbsolute = 5)
|> yLine(length = 3.14, tag = $a)
|> xLine(length = 3.14)
|> angledLineOfXLength([3.14, 3.14], %)
|> angledLineOfYLength([30, 3], %)
|> angledLineToX([12, 12], %)
|> angledLineToY([30, 10], %)
|> angledLine(angle = 3.14, lengthX = 3.14)
|> angledLine(angle = 30, lengthY = 3)
|> angledLine(angle = 12, endAbsoluteX = 12)
|> angledLine(angle = 30, endAbsoluteY = 10)
|> angledLineThatIntersects({
angle = 3.14,
intersectTag = a,
@ -858,7 +858,7 @@ describe('testing getConstraintInfo', () => {
const code = `const part001 = startSketchOn(-XZ)
|> startProfileAt([0, 0], %)
|> line(end = [3 + 0, 4 + 0])
|> angledLine({ angle = 3.14 + 0, length = 3.14 + 0 }, %)
|> angledLine(angle = 3.14 + 0, length = 3.14 + 0 )
|> line(endAbsolute = [6.14 + 0, 3.14 + 0])
|> xLine(endAbsolute = 8 + 0)
|> yLine(endAbsolute = 5 + 0)
@ -866,8 +866,8 @@ describe('testing getConstraintInfo', () => {
|> xLine(length = 3.14 + 0)
|> angledLineOfXLength({ angle = 3.14 + 0, length = 3.14 + 0 }, %)
|> angledLineOfYLength({ angle = 30 + 0, length = 3 + 0 }, %)
|> angledLineToX({ angle = 12.14 + 0, to = 12 + 0 }, %)
|> angledLineToY({ angle = 30 + 0, to = 10.14 + 0 }, %)
|> angledLine(angle = 12.14 + 0, endAbsoluteX = 12 + 0)
|> angledLine(angle = 30 + 0, endAbsoluteY = 10.14 + 0)
|> angledLineThatIntersects({
angle = 3.14 + 0,
intersectTag = a,

52
src/lang/std/sketchConstraints.test.ts
View File

@ -74,22 +74,22 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
` |> startProfileAt([0, 0], %)`,
` |> line(endAbsolute = [1, 1], tag = $abc1)`,
` |> line(end = [-2.04, -0.7], tag = $abc2)`,
` |> angledLine({ angle = 157, length = 1.69 }, %, $abc3)`,
` |> angledLine(angle = 157, length = 1.69 , tag = $abc3)`,
` |> angledLineOfXLength({ angle = 217, length = 0.86 }, %, $abc4)`,
` |> angledLineOfYLength({ angle = 104, length = 1.58 }, %, $abc5)`,
` |> angledLineToX({ angle = 55, to = -2.89 }, %, $abc6)`,
` |> angledLineToY({ angle = 330, to = 2.53 }, %, $abc7)`,
` |> angledLine(angle = 55, endAbsoluteX = -2.89, tag = $abc6)`,
` |> angledLine(angle = 330, endAbsoluteY = 2.53, tag = $abc7)`,
` |> xLine(length = 1.47, tag = $abc8)`,
` |> yLine(length = 1.57, tag = $abc9)`,
` |> xLine(endAbsolute = 1.49, tag = $abc10)`,
` |> yLine(endAbsolute = 2.64, tag = $abc11)`,
` |> line(endAbsolute = [2.55, 3.58]) // lineTo`,
` |> line(end = [0.73, -0.75])`,
` |> angledLine([63, 1.38], %) // angledLine`,
` |> angledLineOfXLength([319, 1.15], %) // angledLineOfXLength`,
` |> angledLineOfYLength([50, 1.35], %) // angledLineOfYLength`,
` |> angledLineToX([291, 6.66], %) // angledLineToX`,
` |> angledLineToY([228, 2.14], %) // angledLineToY`,
` |> angledLine(angle = 63, length = 1.38) // angledLine`,
` |> angledLine(angle = 319, lengthX = 1.15) // angledLineOfXLength`,
` |> angledLine(angle = 50, lengthY = 1.35) // angledLineOfYLength`,
` |> angledLine(angle = 291, endAbsoluteX = 6.66) // angledLineToX`,
` |> angledLine(angle = 228, endAbsoluteY = 2.14) // angledLineToY`,
` |> xLine(length = -1.33)`,
` |> yLine(length = -1.07)`,
` |> xLine(endAbsolute = 3.27)`,
@ -145,7 +145,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLine with tag converts to xLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLine({ angle = 157, length = 1.69 }, %, $abc3)',
callToSwap: 'angledLine(angle = 157, length = 1.69 , tag = $abc3)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(length = -1.56, tag = $abc3)'
@ -157,7 +157,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLine w/o tag converts to xLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLine([63, 1.38], %)',
callToSwap: 'angledLine(angle = 63, length = 1.38)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(length = 0.63) // angledLine'
@ -181,7 +181,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineOfXLength w/o tag converts to xLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineOfXLength([319, 1.15], %)',
callToSwap: 'angledLine(angle = 319, lengthX = 1.15)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(length = 1.15) // angledLineOfXLength'
@ -204,7 +204,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineOfYLength w/o tag converts to yLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineOfYLength([50, 1.35], %)',
callToSwap: 'angledLine(angle = 50, lengthY = 1.35)',
constraintType: 'vertical',
})
const expectedLine = 'yLine(length = 1.35) // angledLineOfYLength'
@ -215,7 +215,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineToX with tag converts to xLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineToX({ angle = 55, to = -2.89 }, %, $abc6)',
callToSwap: 'angledLine(angle = 55, endAbsoluteX = -2.89, tag = $abc6)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(endAbsolute = -2.89, tag = $abc6)'
@ -226,7 +226,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineToX w/o tag converts to xLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineToX([291, 6.66], %)',
callToSwap: 'angledLine(angle = 291, endAbsoluteX = 6.66)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(endAbsolute = 6.66) // angledLineToX'
@ -237,7 +237,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineToY with tag converts to yLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineToY({ angle = 330, to = 2.53 }, %, $abc7)',
callToSwap: 'angledLine(angle = 330, endAbsoluteY = 2.53, tag = $abc7)',
constraintType: 'vertical',
})
const expectedLine = 'yLine(endAbsolute = 2.53, tag = $abc7)'
@ -248,7 +248,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo', () => {
it('angledLineToY w/o tag converts to yLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: bigExample,
callToSwap: 'angledLineToY([228, 2.14], %)',
callToSwap: 'angledLine(angle = 228, endAbsoluteY = 2.14)',
constraintType: 'vertical',
})
const expectedLine = 'yLine(endAbsolute = 2.14) // angledLineToY'
@ -274,11 +274,11 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
` |> line(endAbsolute = [1, 1])`,
` |> line(end = [lineX, 2.13])`,
` |> line(endAbsolute = [lineToX, 2.85])`,
` |> angledLine([angledLineAngle, 1.64], %)`,
` |> angledLineOfXLength([329, angledLineOfXLengthX], %)`,
` |> angledLineOfYLength([222, angledLineOfYLengthY], %)`,
` |> angledLineToX([330, angledLineToXx], %)`,
` |> angledLineToY([217, angledLineToYy], %)`,
` |> angledLine(angle = angledLineAngle, length = 1.64)`,
` |> angledLine(angle = 329, lengthX = angledLineOfXLengthX)`,
` |> angledLine(angle = 222, lengthY = angledLineOfYLengthY)`,
` |> angledLine(angle = 330, endAbsoluteX = angledLineToXx)`,
` |> angledLine(angle = 217, endAbsoluteY = angledLineToYy)`,
` |> line(end = [0.89, -0.1])`,
]
const varExample = variablesExampleArr.join('\n')
@ -307,7 +307,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
it('angledLineOfXLength keeps variable when converted to xLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: varExample,
callToSwap: 'angledLineOfXLength([329, angledLineOfXLengthX], %)',
callToSwap: 'angledLine(angle = 329, lengthX = angledLineOfXLengthX)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(length = angledLineOfXLengthX)'
@ -318,7 +318,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
it('angledLineOfYLength keeps variable when converted to yLine', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: varExample,
callToSwap: 'angledLineOfYLength([222, angledLineOfYLengthY], %)',
callToSwap: 'angledLine(angle = 222, lengthY = angledLineOfYLengthY)',
constraintType: 'vertical',
})
const expectedLine = 'yLine(length = -angledLineOfYLengthY)'
@ -329,7 +329,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
it('angledLineToX keeps variable when converted to xLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: varExample,
callToSwap: 'angledLineToX([330, angledLineToXx], %)',
callToSwap: 'angledLine(angle = 330, endAbsoluteX = angledLineToXx)',
constraintType: 'horizontal',
})
const expectedLine = 'xLine(endAbsolute = angledLineToXx)'
@ -340,7 +340,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
it('angledLineToY keeps variable when converted to yLineTo', async () => {
const { newCode, originalRange } = await testingSwapSketchFnCall({
inputCode: varExample,
callToSwap: 'angledLineToY([217, angledLineToYy], %)',
callToSwap: 'angledLine(angle = 217, endAbsoluteY = angledLineToYy)',
constraintType: 'vertical',
})
const expectedLine = 'yLine(endAbsolute = angledLineToYy)'
@ -353,7 +353,7 @@ describe('testing swapping out sketch calls with xLine/xLineTo while keeping var
const illegalConvert = () =>
testingSwapSketchFnCall({
inputCode: varExample,
callToSwap: 'angledLineToY([217, angledLineToYy], %)',
callToSwap: 'angledLine(angle = 217, endAbsoluteY = angledLineToYy)',
constraintType: 'horizontal',
})
await expect(illegalConvert).rejects.toThrowError('no callback helper')

2
src/lang/std/sketchConstraints.ts
View File

@ -100,7 +100,7 @@ export function isSketchVariablesLinked(
|> line(end = [myVar, 0.38]) // ❗️ <- cursor in this fn call (the primary)
|> line(end = [0.41, baz])
|> xLine(length = 0.91)
|> angledLine([37, 2], %)
|> angledLine(angle = 37, length = 2)
const yo = line(end = [myVar, 0.38], tag = part001)
|> line(end = [1, 1])
const yo2 = line(end = [myVar, 0.38], tag = yo)

126
src/lang/std/sketchcombos.test.ts
View File

@ -35,24 +35,24 @@ describe('testing getConstraintType', () => {
expect(helper(`line(endAbsolute = [myVar, 5])`)).toBe('xAbsolute')
})
it('testing angledLine', () => {
expect(helper(`angledLine([5, myVar], %)`)).toBe('length')
expect(helper(`angledLine([myVar, 5], %)`)).toBe('angle')
expect(helper(`angledLine(angle = 5, length = myVar)`)).toBe('length')
expect(helper(`angledLine(angle = myVar, length = 5)`)).toBe('angle')
})
it('testing angledLineOfXLength', () => {
expect(helper(`angledLineOfXLength([5, myVar], %)`)).toBe('xRelative')
expect(helper(`angledLineOfXLength([myVar, 5], %)`)).toBe('angle')
expect(helper(`angledLine(angle = 5, lengthX = myVar)`)).toBe('xRelative')
expect(helper(`angledLine(angle = myVar, lengthX = 5)`)).toBe('angle')
})
it('testing angledLineToX', () => {
expect(helper(`angledLineToX([5, myVar], %)`)).toBe('xAbsolute')
expect(helper(`angledLineToX([myVar, 5], %)`)).toBe('angle')
expect(helper(`angledLine(angle = 5, endAbsoluteX = myVar)`)).toBe('xAbsolute')
expect(helper(`angledLine(angle = myVar, endAbsoluteX = 5)`)).toBe('angle')
})
it('testing angledLineOfYLength', () => {
expect(helper(`angledLineOfYLength([5, myVar], %)`)).toBe('yRelative')
expect(helper(`angledLineOfYLength([myVar, 5], %)`)).toBe('angle')
expect(helper(`angledLine(angle = 5, lengthY = myVar)`)).toBe('yRelative')
expect(helper(`angledLine(angle = myVar, lengthY = 5)`)).toBe('angle')
})
it('testing angledLineToY', () => {
expect(helper(`angledLineToY([5, myVar], %)`)).toBe('yAbsolute')
expect(helper(`angledLineToY([myVar, 5], %)`)).toBe('angle')
expect(helper(`angledLine(angle = 5, endAbsoluteY = myVar)`)).toBe('yAbsolute')
expect(helper(`angledLine(angle = myVar, endAbsoluteY = 5)`)).toBe('angle')
})
const helper2 = getConstraintTypeFromSourceHelper2
it('testing xLine', () => {
@ -174,7 +174,7 @@ describe('testing transformAstForSketchLines for equal length constraint', () =>
const expectedModifiedScript = `sketch001 = startSketchOn(XZ)
|> startProfileAt([0, 0], %)
|> line(end = [5, 5], tag = $seg01)
|> angledLine([112, segLen(seg01)], %)
|> angledLine(angle = 112, length = segLen(seg01))
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
`
@ -258,26 +258,26 @@ part001 = startSketchOn(XY)
|> line(endAbsolute = [myVar, 1]) // ln-lineTo-xAbsolute should use angleToMatchLengthX helper
|> line(endAbsolute = [1, myVar]) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper
|> line(endAbsolute = [2, 4]) // ln-lineTo-free should become angledLine
|> angledLineToX([45, 2.5], %) // ln-angledLineToX-free should become angledLine
|> angledLineToX([myAng, 3], %) // ln-angledLineToX-angle should become angledLine
|> angledLineToX([45, myVar2], %) // ln-angledLineToX-xAbsolute should use angleToMatchLengthX to get angle
|> angledLineToY([135, 5], %) // ln-angledLineToY-free should become angledLine
|> angledLineToY([myAng2, 4], %) // ln-angledLineToY-angle should become angledLine
|> angledLineToY([45, myVar3], %) // ln-angledLineToY-yAbsolute should use angleToMatchLengthY to get angle
|> angledLine(angle = 45, endAbsoluteX = 2.5) // ln-angledLineToX-free should become angledLine
|> angledLine(angle = myAng, endAbsoluteX = 3) // ln-angledLineToX-angle should become angledLine
|> angledLine(angle = 45, endAbsoluteX = myVar2) // ln-angledLineToX-xAbsolute should use angleToMatchLengthX to get angle
|> angledLine(angle = 135, endAbsoluteY = 5) // ln-angledLineToY-free should become angledLine
|> angledLine(angle = myAng2, endAbsoluteY = 4) // ln-angledLineToY-angle should become angledLine
|> angledLine(angle = 45, endAbsoluteY = myVar3) // ln-angledLineToY-yAbsolute should use angleToMatchLengthY to get angle
|> line(end = [myVar, 1]) // ln-should use legLen for y
|> line(end = [myVar, -1]) // ln-legLen but negative
|> line(end = [-0.62, -1.54]) // ln-should become angledLine
|> angledLine([myVar, 1.04], %) // ln-use segLen for second arg
|> angledLine([45, 1.04], %) // ln-segLen again
|> angledLineOfXLength([54, 2.35], %) // ln-should be transformed to angledLine
|> angledLineOfXLength([50, myVar], %) // ln-should use legAngX to calculate angle
|> angledLineOfXLength([209, myVar], %) // ln-same as above but should have + 180 to match original quadrant
|> angledLine(angle = myVar, length = 1.04) // ln-use segLen for second arg
|> angledLine(angle = 45, length = 1.04) // ln-segLen again
|> angledLine(angle = 54, lengthX = 2.35) // ln-should be transformed to angledLine
|> angledLine(angle = 50, lengthX = myVar) // ln-should use legAngX to calculate angle
|> angledLine(angle = 209, lengthX = myVar) // ln-same as above but should have + 180 to match original quadrant
|> line(end = [1, myVar]) // ln-legLen again but yRelative
|> line(end = [-1, myVar]) // ln-negative legLen yRelative
|> angledLineOfYLength([58, 0.7], %) // ln-angledLineOfYLength-free should become angledLine
|> angledLineOfYLength([myAng, 0.7], %) // ln-angledLineOfYLength-angle should become angledLine
|> angledLineOfYLength([35, myVar], %) // ln-angledLineOfYLength-yRelative use legAngY
|> angledLineOfYLength([305, myVar], %) // ln-angledLineOfYLength-yRelative with angle > 90 use binExp
|> angledLine(angle = 58, lengthY = 0.7) // ln-angledLineOfYLength-free should become angledLine
|> angledLine(angle = myAng, lengthY = 0.7) // ln-angledLineOfYLength-angle should become angledLine
|> angledLine(angle = 35, lengthY = myVar) // ln-angledLineOfYLength-yRelative use legAngY
|> angledLine(angle = 305, lengthY = myVar) // ln-angledLineOfYLength-yRelative with angle > 90 use binExp
|> xLine(length = 1.03) // ln-xLine-free should sub in segLen
|> yLine(length = 1.04) // ln-yLine-free should sub in segLen
|> xLine(endAbsolute = 30) // ln-xLineTo-free should convert to xLine
@ -299,15 +299,15 @@ part001 = startSketchOn(XY)
-angleToMatchLengthY(seg01, myVar, %),
myVar
], %) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper
|> angledLine([45, segLen(seg01)], %) // ln-lineTo-free should become angledLine
|> angledLine([45, segLen(seg01)], %) // ln-angledLineToX-free should become angledLine
|> angledLine([myAng, segLen(seg01)], %) // ln-angledLineToX-angle should become angledLine
|> angledLine(angle = 45, length = segLen(seg01)) // ln-lineTo-free should become angledLine
|> angledLine(angle = 45, length = segLen(seg01)) // ln-angledLineToX-free should become angledLine
|> angledLine(angle = myAng, length = segLen(seg01)) // ln-angledLineToX-angle should become angledLine
|> angledLineToX([
angleToMatchLengthX(seg01, myVar2, %),
myVar2
], %) // ln-angledLineToX-xAbsolute should use angleToMatchLengthX to get angle
|> angledLine([-45, segLen(seg01)], %) // ln-angledLineToY-free should become angledLine
|> angledLine([myAng2, segLen(seg01)], %) // ln-angledLineToY-angle should become angledLine
|> angledLine(angle = -45, length = segLen(seg01)) // ln-angledLineToY-free should become angledLine
|> angledLine(angle = myAng2, length = segLen(seg01)) // ln-angledLineToY-angle should become angledLine
|> angledLineToY([
angleToMatchLengthY(seg01, myVar3, %),
myVar3
@ -320,10 +320,10 @@ part001 = startSketchOn(XY)
min(segLen(seg01), myVar),
-legLen(segLen(seg01), myVar)
]) // ln-legLen but negative
|> angledLine([-112, segLen(seg01)], %) // ln-should become angledLine
|> angledLine([myVar, segLen(seg01)], %) // ln-use segLen for second arg
|> angledLine([45, segLen(seg01)], %) // ln-segLen again
|> angledLine([54, segLen(seg01)], %) // ln-should be transformed to angledLine
|> angledLine(angle = -112, length = segLen(seg01)) // ln-should become angledLine
|> angledLine(angle = myVar, length = segLen(seg01)) // ln-use segLen for second arg
|> angledLine(angle = 45, length = segLen(seg01)) // ln-segLen again
|> angledLine(angle = 54, length = segLen(seg01)) // ln-should be transformed to angledLine
|> angledLineOfXLength([
legAngX(segLen(seg01), myVar),
min(segLen(seg01), myVar)
@ -340,8 +340,8 @@ part001 = startSketchOn(XY)
-legLen(segLen(seg01), myVar),
min(segLen(seg01), myVar)
]) // ln-negative legLen yRelative
|> angledLine([58, segLen(seg01)], %) // ln-angledLineOfYLength-free should become angledLine
|> angledLine([myAng, segLen(seg01)], %) // ln-angledLineOfYLength-angle should become angledLine
|> angledLine(angle = 58, length = segLen(seg01)) // ln-angledLineOfYLength-free should become angledLine
|> angledLine(angle = myAng, length = segLen(seg01)) // ln-angledLineOfYLength-angle should become angledLine
|> angledLineOfXLength([
legAngY(segLen(seg01), myVar),
min(segLen(seg01), myVar)
@ -404,18 +404,18 @@ part001 = startSketchOn(XY)
|> line(endAbsolute = [3, 11]) // select for vertical constraint 3
|> line(endAbsolute = [myVar2, 12.63]) // select for horizontal constraint 4
|> line(endAbsolute = [4.08, myVar2]) // select for vertical constraint 4
|> angledLine([156, 1.34], %) // select for horizontal constraint 5
|> angledLine([103, 1.44], %) // select for vertical constraint 5
|> angledLine([-178, myVar], %) // select for horizontal constraint 6
|> angledLine([129, myVar], %) // select for vertical constraint 6
|> angledLineOfXLength([237, 1.05], %) // select for horizontal constraint 7
|> angledLineOfYLength([196, 1.11], %) // select for vertical constraint 7
|> angledLineOfXLength([194, myVar], %) // select for horizontal constraint 8
|> angledLineOfYLength([248, myVar], %) // select for vertical constraint 8
|> angledLineToX([202, -10.92], %) // select for horizontal constraint 9
|> angledLineToY([223, 7.68], %) // select for vertical constraint 9
|> angledLineToX([333, myVar3], %) // select for horizontal constraint 10
|> angledLineToY([301, myVar], %) // select for vertical constraint 10
|> angledLine(angle = 156, length = 1.34) // select for horizontal constraint 5
|> angledLine(angle = 103, length = 1.44) // select for vertical constraint 5
|> angledLine(angle = -178, length = myVar) // select for horizontal constraint 6
|> angledLine(angle = 129, length = myVar) // select for vertical constraint 6
|> angledLine(angle = 237, lengthX = 1.05) // select for horizontal constraint 7
|> angledLine(angle = 196, lengthY = 1.11) // select for vertical constraint 7
|> angledLine(angle = 194, lengthX = myVar) // select for horizontal constraint 8
|> angledLine(angle = 248, lengthY = myVar) // select for vertical constraint 8
|> angledLine(angle = 202, endAbsoluteX = -10.92) // select for horizontal constraint 9
|> angledLine(angle = 223, endAbsoluteY = 7.68) // select for vertical constraint 9
|> angledLine(angle = 333, endAbsoluteX = myVar3) // select for horizontal constraint 10
|> angledLine(angle = 301, endAbsoluteY = myVar) // select for vertical constraint 10
`
it('should transform horizontal lines the ast', async () => {
const expectModifiedScript = `myVar = 2
@ -433,17 +433,17 @@ part001 = startSketchOn(XY)
|> xLine(endAbsolute = myVar2) // select for horizontal constraint 4
|> line(endAbsolute = [4.08, myVar2]) // select for vertical constraint 4
|> xLine(length = -1.22) // select for horizontal constraint 5
|> angledLine([103, 1.44], %) // select for vertical constraint 5
|> angledLine(angle = 103, length = 1.44) // select for vertical constraint 5
|> xLine(length = -myVar) // select for horizontal constraint 6
|> angledLine([129, myVar], %) // select for vertical constraint 6
|> angledLine(angle = 129, length = myVar) // select for vertical constraint 6
|> xLine(length = -1.05) // select for horizontal constraint 7
|> angledLineOfYLength([196, 1.11], %) // select for vertical constraint 7
|> angledLine(angle = 196, lengthY = 1.11) // select for vertical constraint 7
|> xLine(length = -myVar) // select for horizontal constraint 8
|> angledLineOfYLength([248, myVar], %) // select for vertical constraint 8
|> angledLine(angle = 248, lengthY = myVar) // select for vertical constraint 8
|> xLine(endAbsolute = -10.92) // select for horizontal constraint 9
|> angledLineToY([223, 7.68], %) // select for vertical constraint 9
|> angledLine(angle = 223, endAbsoluteY = 7.68) // select for vertical constraint 9
|> xLine(endAbsolute = myVar3) // select for horizontal constraint 10
|> angledLineToY([301, myVar], %) // select for vertical constraint 10
|> angledLine(angle = 301, endAbsoluteY = myVar) // select for vertical constraint 10
`
const ast = assertParse(inputScript)
@ -492,17 +492,17 @@ part001 = startSketchOn(XY)
|> yLine(endAbsolute = 11) // select for vertical constraint 3
|> line(endAbsolute = [myVar2, 12.63]) // select for horizontal constraint 4
|> yLine(endAbsolute = myVar2) // select for vertical constraint 4
|> angledLine([156, 1.34], %) // select for horizontal constraint 5
|> angledLine(angle = 156, length = 1.34) // select for horizontal constraint 5
|> yLine(length = 1.4) // select for vertical constraint 5
|> angledLine([-178, myVar], %) // select for horizontal constraint 6
|> angledLine(angle = -178, length = myVar) // select for horizontal constraint 6
|> yLine(length = myVar) // select for vertical constraint 6
|> angledLineOfXLength([237, 1.05], %) // select for horizontal constraint 7
|> angledLine(angle = 237, lengthX = 1.05) // select for horizontal constraint 7
|> yLine(length = -1.11) // select for vertical constraint 7
|> angledLineOfXLength([194, myVar], %) // select for horizontal constraint 8
|> angledLine(angle = 194, lengthX = myVar) // select for horizontal constraint 8
|> yLine(length = -myVar) // select for vertical constraint 8
|> angledLineToX([202, -10.92], %) // select for horizontal constraint 9
|> angledLine(angle = 202, endAbsoluteX = -10.92) // select for horizontal constraint 9
|> yLine(endAbsolute = 7.68) // select for vertical constraint 9
|> angledLineToX([333, myVar3], %) // select for horizontal constraint 10
|> angledLine(angle = 333, endAbsoluteX = myVar3) // select for horizontal constraint 10
|> yLine(endAbsolute = myVar) // select for vertical constraint 10
`
const ast = assertParse(inputScript)
@ -659,12 +659,12 @@ part001 = startSketchOn(XY)
|> xLine(length = 4.4) // partial
|> yLine(length = -1) // partial
|> xLine(length = -4.2 + 0) // full
|> angledLine([segAng(seg01bing) + 180, 1.79], %) // partial
|> angledLine(angle = segAng(seg01bing) + 180, length = 1.79) // partial
|> line(end = [1.44, -0.74]) // free
|> xLine(length = 3.36) // partial
|> line(end = [1.49, 1.06]) // free
|> xLine(length = -3.43 + 0) // full
|> angledLineOfXLength([243 + 0, 1.2 + 0], %) // full`
|> angledLine(angle = 243 + 0, lengthX = 1.2 + 0) // full`
const ast = assertParse(code)
const constraintLevels: ConstraintLevel[] = ['full', 'partial', 'free']
constraintLevels.forEach((constraintLevel) => {

8
src/lib/rectangleTool.test.ts
View File

@ -19,8 +19,8 @@ describe('library rectangleTool helper functions', () => {
// Base source code that will be edited in place
const sourceCode = `sketch001 = startSketchOn(XZ)
|> startProfileAt([120.37, 162.76], %)
|> angledLine([0, 0], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) + 90, 0], %, $rectangleSegmentB001)
|> angledLine(angle = 0, length = 0, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) + 90, length = 0, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
@ -72,8 +72,8 @@ segAng(rectangleSegmentA001),
// ast is edited in place from the updateCenterRectangleSketch
const expectedSourceCode = `sketch001 = startSketchOn(XZ)
|> startProfileAt([120.37, 80], %)
|> angledLine([0, 0], %, $rectangleSegmentA001)
|> angledLine([segAng(rectangleSegmentA001) + 90, 0], %, $rectangleSegmentB001)
|> angledLine(angle = 0, length = 0, tag = $rectangleSegmentA001)
|> angledLine(angle = segAng(rectangleSegmentA001) + 90, length = 0, tag = $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)

6
src/lib/rectangleTool.ts
View File

@ -30,9 +30,9 @@ import { roundOff } from '@src/lib/utils'
* Returns AST expressions for this KCL code:
* const yo = startSketchOn(XY)
* |> startProfileAt([0, 0], %)
* |> angledLine([0, 0], %, $a)
* |> angledLine([segAng(a) - 90, 0], %, $b)
* |> angledLine([segAng(a), -segLen(a)], %, $c)
* |> angledLine(angle = 0, length = 0, tag = $a)
* |> angledLine(angle = segAng(a) - 90, length = 0, tag = $b)
* |> angledLine(angle = segAng(a), length = -segLen(a), tag = $c)
* |> close()
*/
export const getRectangleCallExpressions = (

4
src/lib/selections.test.ts
View File

@ -40,7 +40,7 @@ profile006 = circle(sketch005,
)
sketch004 = startSketchOn(extrude001, seg02)
profile005 = startProfileAt([36.1, 174.49], sketch004)
|> angledLine([0, 22.33], %, $rectangleSegmentA003)
|> angledLine(angle = 0, length = 22.33, tag = $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
155.27
@ -53,7 +53,7 @@ profile005 = startProfileAt([36.1, 174.49], sketch004)
|> close()
sketch003 = startSketchOn(extrude001, seg02)
profile003 = startProfileAt([-115.59, 439.4], sketch003)
|> angledLine([0, 130.08], %, $rectangleSegmentA002)
|> angledLine(angle = 0, length = 130.08, tag = $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
123.84